pyRFtk package — pyRFtk 2.0.0 documentation

# pyRFtk package

## Submodules

## pyRFtk.ConvertGeneral module

pyRFtk.ConvertGeneral.ConvertGeneral(Z2, S1, Z1, type1='V', type2='V')

  CovertGeneral(Z2, S1, Z1, type1=”V”¸ type2=”V”)

  Converts (an array of N frequencies of) scattering matrice(s) of type1 and port impedance(s) Z1 to type2 and port impedance(s) Z2

  Z1, Z2port impedance(s)
    scalar

      all port impedances are the same for all ports and frequencies

    1D-list/array

      length must correspond to the number of ports; ports have different impedances but it is the same for all frequencies

    2D-list/array :

      the shape corresponds to (nF, nP)

  S1 input S-matri-x/ces
    shape:

      scalar -> nFreqs = 1, nPorts=1 -> (1,1,1) 1D-list -> nFreqs=#, nPorts=1 -> (#,1,1) 2D-list -> nFreqs=1, nPorts=# -> (1,#,#) 3D-list -> nFreqs=*, nPorts=# -> (*,#,#)

  type1, type2 : S-matrix types

  > “P”power wave Zk.imag==0

  >   ak=(Vk+Zk.Ik)/(2.Zk**0.5) bk=(Vk-Zk.Ik)/(2.Zk**0.5)

  > “V”voltage waveZk.imag==0

  >   ak=(Vk+Zk.Ik)/2, bk=(Vk-Zk.Ik)/2

  > “G”generalized s-matrix [Orfanidis] waveZk.imag!=0

  >   ak=(Vk+Zk.Ik)/(2.Zk.real**0.5) bk=(Vk-Zk.Ik)/(2.Zk.real**0.5)

  S2converted S-matri-x/ces

    return value has the shape of S1

## pyRFtk.ReadDictData module

pyRFtk.ReadDictData.ReadDictData(fpath, userdirs=['.'], envvar='', appdirs=[], missingOK=True, verbose=False)

  read a text file representing a model (.mod4PJ, .model, .ciamod, …) and return the dict object

pyRFtk.ReadDictData.ReadDictString(s)

## pyRFtk.ReadTSF module

pyRFtk.ReadTSF.ReadTSF(src, **kwargs)

  read_tsf

  read a touchstone file version 1

  special comments:

    !PORTS str, str, … , str !PART (TOP|BOTTOM)?(LEFT|RIGHT)? !SHAPE tuple of int !NUMBERING (UP|DOWN)? !REM !MARKERS list of frequencies

## pyRFtk.S_from_VI module

pyRFtk.S_from_VI.S_from_VI(M, Z0=30.0)

  returns the S on reference imedance Z0 from the VI transformation matrix M :

  note S is defined for an oposite sign of I1 shown above (i.e. standard)

## pyRFtk.S_from_Y module

pyRFtk.S_from_Y.S_from_Y(Y, Zbase=50.0)

  returns the scattering matrix S defined on Zbase [Ohm] from an admittance matrix Y

  always returns an numpy.ndarray unless the Z is a scalar

## pyRFtk.S_from_Z module

pyRFtk.S_from_Z.S_from_Z(Z, Zbase=50.0)

  returns the scattering matrix S defined on Zbase [Ohm] from an impedance matrix Z

  always returns an numpy.ndarray unless the Z is a scalar

## pyRFtk.Y_from_S module

pyRFtk.Y_from_S.Y_from_S(S, Zbase=50.0)

  returns the scattering matrix S defined on Zbase [Ohm] from an admittance matrix Y

  always returns an numpy.ndarray unless the Z is a scalar

## pyRFtk.Z_from_S module

pyRFtk.Z_from_S.Z_from_S(S, Zbase=50.0)

  returns the scattering matrix S defined on Zbase [Ohm] from an impedance matrix Z

  always returns an numpy.ndarray unless the Z is a scalar

## pyRFtk.circuit module

class pyRFtk.circuit.circuit(**kwargs)

  Bases: `object`

  > Deprecated since version 1.0.0: ‘circuit’ has been replaced by ‘rfCircuit’ but kept here for compatibility with legacy code

  > this implements a circuit class for manipulating RFbase objects

  > RFobject must implement following methods/attributes

  >   (attribute) Zbase float (attribute) ports list of strings (method) __len__ integer = number of ports (#p) (method) getS input:

  >   > > fs float or list/array of floats, frequencies in Hz Zbase float, params dict

  >   > output: - list/array of f’s -> array of Smatrices [#f,#p,#p]

  >   > > single f -> single Smatrix [#p,#p]

  >   > - the resulting Smatrices are converted to Zbase if given else the Smatrix is given in the circuit’s Zbase (default 50 Ohm)

  >   (method) set *args, **kwargs

  > circuit building methods

  >   addblock(name, RFobj, ports, params) connect(*ports) terminate(port, Z=complex | Y=complex | RC=complex)

  unused ports automatically become external ports

  Get_internalSmatrix(f, nodes, Zbase=None)

    given a set of (internal) nodes try and find a corresponding Smatrix

  Solution(f. E, Zbase=self.Zbase, nodes=None, flags={})

    returns a dict of (node, (V, I, Vf, Vr)) pairs for a excitation E at the fequency f [Hz] where node is the node’s name, V its voltage, I the current flowing into the node, Vf the forward voltage wave into the node and Vr the voltage wave reflected from the node.

    E and the returned voltage wave quantities are expressed for a reference impedance Zbase which defaults to the circuit’s one.

  addblock(name, RFobj, ports=None, params={}, **kwargs)

    inputs: name : str an ID of the added block RFobj : the added rf object:

    > this object must minimally implement __len__ returning

    >   the number of ports

    portsa port mapping

      - can be a list of length the number of ports

      - of a dict mapping the PF object’s portnames to new

          names.

      - or ommitted to generate a generic set of names

    paramsthe parameters that will be supplied to the RFobject’s

      getS(…) method

    kwargs:
      xpos: the (relative) position of the RFobject’s ports

        - can be a scalar

        - a list of lenght the number of ports

  connect(*ports)

    inputs are existing as well as not yet existing ports

  copy()
  extS()
    extS returns the S-matrix solution of the current state of the

      circuit matrix for the circuit’s base impedance (self.Zbase)

      it is called after e.g. getS(f, Zbase, params) has recursively filled all the circuit’s block S-matrices in its matrix.

  getS(fs, Zbase=None, params={}, flags={})
  listBlocks()
  maxV(f, E, Zbase=None, Id=None, flags={}, **kwargs)

    kwargs : future extesnsion ? xpos: list-like position of ports

  set(**kwargs)
  solve(f, E, Zbase)

    solves the circuit for the excitation given in Zbase (defaults to self.Zbase) and flags (defaults to no flags) at frequency f

    returns the solution at all nodes

  terminate(port, **kwargs)

## pyRFtk.codebase module

pyRFtk.codebase.list1dir(path, level=' ')

## pyRFtk.compareSs module

pyRFtk.compareSs.compareSs(fs, Ss, cs=[], lbls=[], **figkwargs)

## pyRFtk.config module

pyRFtk.config.CleanUpLogFile()

pyRFtk.config.fscale(frm, to='Hz')

pyRFtk.config.get_class_that_defined_method(meth)

pyRFtk.config.ident(message, d=0)

pyRFtk.config.logident(message, printargs=False, stacklev=2)

pyRFtk.config.setLogLevel(level)

## pyRFtk.findpath module

pyRFtk.findpath.existspath(fpattern, userdirs=['.'], envvar='', appdirs=[], missingOK=True, verbose=False)

  same as findpath but does not raise an exception : just return an empty string

pyRFtk.findpath.findpath(fpattern, userdirs, envar, appdirs, missingOK, verbose)

  fpattern : the file’s basename to search for

  envvarif an environment variable is set with aseparated set of

    directories then these directories will be searched first in the order of appearance in the environment variable (default : ‘’)

  usersdirslist of directories searched next in order of appearance

    (default [‘.’])

  appdirslist of directories searched finally in order of appearance

    (default [])

  missingOK : do not raise IOError when a directory does not exist

  verbose : print debugging messages

## pyRFtk.getlines module

pyRFtk.getlines.getlines(src)

  Given a source return an iterator function returning the next line of text in the source.

  The source can be a multiline string, a string path to a file or a file descriptor such as returned when opening a file.

## pyRFtk.maxfun module

pyRFtk.maxfun.maxfun(xs, ys)

## pyRFtk.plotVSWs module

pyRFtk.plotVSWs.plotVSWs(VSWs, maxlev=4, Id=None, **kwargs)

pyRFtk.plotVSWs.scaleVSW(VSW, scale)

pyRFtk.plotVSWs.strVSW(VSW, indent=0)

## pyRFtk.printMatrices module

pyRFtk.printMatrices.printDB(C, pfmt='%7.3f%+7.1f°, ', printzeros='0')

  pretty print a complex matrix

pyRFtk.printMatrices.printM(M, pfmt='%7.3f%+7.3fj, ', pfun=<function <lambda>>, printzeros='0')

  pretty str a complex matrix to print or write to a file

pyRFtk.printMatrices.printMA(C, pfmt='%8.5f %+7.2f°, ', printzeros='0')

  pretty print a complex matrix

pyRFtk.printMatrices.printR(R, pfmt='%7.3f, ', printzeros='0')

  pretty print (the real part) of a (possibly complex) matrix

pyRFtk.printMatrices.printRI(C, pfmt='%7.3f%+7.3fj, ', printzeros='0')

  pretty print a complex matrix

pyRFtk.printMatrices.strM(M, pfmt='%7.3f%+7.3fj, ', pfun=<function <lambda>>, printzeros='0')

  pretty ‘str’ a complex matrix

## pyRFtk.resolveTLparams module

class pyRFtk.resolveTLparams.TLresolver(**kwargs)

  Bases: `object`

## pyRFtk.rf3dBHybrid module

## pyRFtk.rfArcObj module

class pyRFtk.rfArcObj.rfArcObj(*args, **kwargs)

  Bases: `rfBase`

  get1S(f)

## pyRFtk.rfBase module

pyRFtk.rfBase.add_debug_code(func)

class pyRFtk.rfBase.rfBase(*args, **kwargs)

  Bases: `object`

  rfBase is the parent class of all RF objects

  __init__ implements the setting of Id, Zbase, portnames copy, __copy__, __deepcopy__ __getstate__, __setstate__ __str__ __len__ get1S, getS tsf2str, write_tsf maxV

  asstr(full=0)
  copy()
  get1S(f)
  getS(fs=None, **kwargs)
  maxV(f, E, Zbase=None, Id=None, xpos=0.0, **kwargs)
  set(**kwargs)

    set attributes of the object if present

  tsf2str(**kwargs)

    return a multiline string which is the touchstone v1 representation of the rfBase object’s data.

    kwargs:
      fs: [Hz] (default self.fs) frequencies to collect in the

        touchstone

      Zbase: [Ohm] (default self.Zbase) get the S-matrix data on

        reference impedance Zbase

      tfmt[] (default f’#MHZ S MA R {self.Zbase}’) the touchstone

        file format

      comments: [] (default self.Id) a multiline comment string added

        at the top of the file

    Note: Zbase is only used when R is not supplied in tfmt to define

      the reference impedance Zref for the touchstone. If Zref is supplied in the tfmt then it overrules Zbase.

  write_tsf(tsbasename, **kwargs)

## pyRFtk.rfCircuit module

class pyRFtk.rfCircuit.rfCircuit(*args, **kwargs)

  Bases: `rfBase`

  this implements a circuit class for manipulating RFbase objects, it depends on the :class: ‘rfObject’ class which must implement following methods/attributes

  > (attribute) Zbase float (attribute) ports list of strings (method) __len__ integer = number of ports (#p) (method) getS input:

  > > > fs float or list/array of floats, frequencies in Hz Zbase float, params dict

  > > output: - list/array of f’s -> array of Smatrices [#f,#p,#p]

  > > > single f -> single Smatrix [#p,#p]

  > > - the resulting Smatrices are converted to Zbase if given else the Smatrix is given in the circuit’s Zbase (default 50 Ohm)

  > (method) set *args, **kwargs

  circuit building methods

    addblock(name, RFobj, ports, params) connect(*ports) terminate(port, Z=complex | Y=complex | RC=complex)

  unused ports automatically become external ports

  TODO: rename and order external ports as requested TODO: rethink on how to set parameters TODO: check logic for the status of solved or not TODO: use external sNp if available

  Get_internalSmatrix(f, nodes, Zbase=None)

    given a set of (internal) nodes try and find a corresponding Smatrix

  Solution(f. E, Zbase=self.Zbase, nodes=None, flags={})

    returns a dict of (node, (V, I, Vf, Vr)) pairs for a excitation E at the fequency f [Hz] where node is the node’s name, V its voltage, I the current flowing into the node, Vf the forward voltage wave into the node and Vr the voltage wave reflected from the node.

    E and the returned voltage wave quantities are expressed for a reference impedance Zbase which defaults to the circuit’s one.

    nodes: None, [ nodes ]

    > If the requested nodes input is None all nodes are evaluated recursively in the whole circuit.

    > If nodes is [] then anyway the nodes at the level if the object are evaluated but the nodes in subblocks are not evaluated.

    > So there may be more nodes evaluated than requested.

  addblock(name, RFobj, ports=None, params={}, **kwargs)

    adds a previously defined circuit block to the circuit

    Parameters:

      - name – str an ID of the added block

      - RFobj –

        the added rf object: this object must minimally implement __len__ returning

        > the number of ports

      - ports –

        a port mapping : - can be a list of length the number of ports - of a dict mapping the PF object’s portnames to new

        > names.

        - or ommitted to generate a generic set of names

      - params – the parameters that will be supplied to the RFobject’s getS(…) method

      - kwargs – relpos: the (relative) position of the RFobject

  connect(*ports)

    connects the specified ports in the circuit.

    Params ports:

      existing as well as not yet existing ports

  deembed(IntPorts={}, ExtPorts={})

    deembeds ports State of the rfCircuit object: it solves for (Sinternal is not explicitly known)

    Parameters:

      - IntPorts –

        list of size 2 tuples or dict [ (rfCircuit.port, rfCircuit.port_new), … ] or { rfCircuit.port:rfCircuit.port_new, … }

        these are the “internal” ports of the circuit i.e. these are connected through the RFobj

      - ExtPorts –

        list of size 2 tuples or dict [ (rfCircuit.port, rfCircuit.port), … ] or { rfCircuit.port:rfCircuit.port, … }

        these are the “external” ports of the circuit i.e. these are connected through the RFobj

  extS()

    returns the S-matrix solution of the current state of the circuit matrix for the circuit’s base impedance (self.Zbase) it is called after e.g. getS(f, Zbase, params) has recursively filled all the circuit’s block S-matrices in its matrix.

  findObj(location)
  getS(fs, Zbase=None, params={}, flags={})
  getpos(node)

    return the position of the node

    Parameters:

      node – The node

  listBlocks()
  maxV(f, E, Zbase=None, Id=None, flags={}, **kwargs)

    kwargs : future extension ?

  resolve_xpos()

    tries to build and xpos based on the underlying blocks’ information

  set(*args, **kwargs)
    kwargs: dict of
      (“blkID”, sdict)

        where sdict is a similar dict that goes further into the chain of nested rf objects

      (“>attr”, value)

        where attr is an rf object’s attribute that gets the value

    e.g.

      rfCircuitA | +- rfRLC1 | | | +- Ls | +- rfCircuitB

      > +- rfTRL1

      >   +- L

    rfCircuitA.set(rfRLC1= {“Ls”:20e-9},

      rfCircuitB= {“rfTRL1”: {“L”:1.0}}

    or

    rfCircuitA.set({‘rfRLC1.Ls’:20e-9,

      ‘rfCircuitB.rfTRL1.L’:1.0’})

    or

    rfCircuitA.set(‘rfRLC1.Ls’, 20e-9) rfCircuitA.set(‘rfCircuitB.rfTRL1’, {‘L:1.0})

    The purpose of the different formalisms:

    > .set(‘kw’, {attr1: val1, attr2: val2}, …)

    or .set((‘kw’, {attr1: val1, attr2: val2}), …) or .set(kw = {attr1: val1, attr2: val2}, …)

    is to be able to set multiple attributes at once.

    in case a single attribute needs to be set:

    > .set(‘kw.attr’, val, …)

    or .set((‘kw.attr’, val), … ) but .set(kw.attr = val, … ) will not work !! thus .set(kw = {‘attr’: val}, … }

    The kwarg formulation is more restrictive if one wants to loop over multiple objects where one wants to set the attributes.

    Possibly the kwarg formalism need to be cancelled ?

  solve(f, E, Zbase)

    solves the circuit for the excitation given in Zbase (defaults to self.Zbase) and flags (defaults to no flags) at frequency f

    sets the solution at all waves in self.sol

  terminate(port, **kwargs)

    terminates the given port, can be either to ground by specifying some Z value or leave it open by specifying Y=0

    Parameters:

      - port – The port to terminate

      - kwargs – With what to terminate the port (e.g Z=5)

## pyRFtk.rfGTL module

pyRFtk.rfGTL.processGTL(fMHz, Zbase, GTL_data, **kwargs)

  a GTL data structure is as follows:

  {‘Portnames’: ordered list of port names (if a sNp touchstone file is

    > provided the order must match),

    ‘sNp’ : optional touchstone file, # * future extension *

    ‘relpos’{‘p1’:position, … } where the p1 are some or all of the

      portnames,

    ‘variables’: { dict of substitutions },

    ‘defaults’ : { dict of default AddBlockGTL kwargs }, # * future extension *

    ‘GTL{

      ‘TLid1’: { # AddBlockGTL kwargs General TL section 1

      > length: float

      > Portnames: [ list of 2 portnames ], # portname =

      >   # str | (str, dict) | dict # dict = CT.Terminate kwargs

      > relpos: float # optional: position of 1st port

      > … General_TL kwargs of the TL properties …

      }, # TLid1

      …

      ‘TLidN’: { AddBlockGTL kwargs General TL section N

      > … TLid 1 …

      }, # TLidN

    }, # GTL

  }

class pyRFtk.rfGTL.rfGTL(path2model, objkey=None, variables={}, **kwargs)

  Bases: `rfCircuit`

  copy()
  getS(fs, Zbase=None, params={}, flags={})
  getSgtl(fs, Zbase=None, params={}, flags={})

## pyRFtk.rfObject module

class pyRFtk.rfObject.rfObject(*args, **kwargs)

  Bases: `object`

  The purpose of rfObject is to create a frequency vs. S-matrix “glorified” LUT

  The creation of the rfObject can be done in several manners:

  1. the simplest is to load a touchstone file e.g. produced by Ansys/HFSS and the likes

     myObject = rfObject(touchstone=<path_to_touchstone>)

  2. another method is the fill the table manually

     portnames = <list of ports> myObject = rfObject(ports = portnames]

     for fHz in fHzs:

       S = <calculate S> myObject.setS(fHz, S)

  Once an rfObject is created the 2 main methods of use are:

  rfObject.getS(fHz, Zbase=None)

  and

  excitation = {port1:a1, … } Vamx, rfObject.maxV(fHz, excitation)

  S_from_Y(Y)

    returns the scattering matrix S defined on Zbase [Ohm] from an impedance matrix Z

  S_from_Z(Z)

    returns the scattering matrix S defined on Zbase [Ohm] from an impedance matrix Z

  convert2newZbase(newZbase)

    convert_Zbase

    converts the rfObject’s Ss and Zbase to newZbase

    newZbase: target reference impedance

  copy()
  deembed(ports)

    deembeds the ports with a simple lossless TL of length L and characteristic impedance Z

    ports is a dict containing the ports to be deembeded: the value is either a scalar (int, float) giving L assuming the default Z being the object’s Zbase or a 2-tuple (L, Z) or a dict which is passed as kwargs to rfTRL.

    Positive L means the deembeding is into the port

  getS(fs, **kw)
  maxV(f, E, Zbase=None, ID='<rfObject>', **kwargs)
  process_kwargs()
  read_tsf(src, **kwargs)
  setS(f, S, Portnames=None)
  sortports(order=<slot wrapper '__lt__' of 'str' objects>)

## pyRFtk.rfRLC module

class pyRFtk.rfRLC.rfRLC(*args, **kwargs)

  Bases: `object`

  19. – Cs – Ls – Rs –+– (p)

        Cp Lp Rp | | | +—+—+

        > Gnd

  kwargs:

    Zbase : reference impedance [50 Ohm] ports : port names [[‘s’,’p’]] Rp : parallel resistance [+inf Ohm] Lp : parallel inductance [+inf H] Cp : parallel capacity [0 F] Rs : series resistance [0 Ohm] Ls : series inductance [0 H] Cs : series capacity [+inf F]

    thus the default is : (s) – (p)

  asstr(full=False)
  copy()
  getS(fs, Zbase=None, params={}, **kw)
  maxV(f, E, Zbase=None, ID=None, **kwargs)
  set(**kwargs)

## pyRFtk.rfTRL module

class pyRFtk.rfTRL.rfTRL(*args, **kwargs)

  Bases: `object`

  this class defines a TL rf object

  Parameters:

    - ID – an identifier (optional) could be used for logging errors and warnings

    - ports – (default [‘1’,’2’]) names the ports on either side of the TL section

    - L – (default 0[m]) total length of the TL section

    - Zbase – (default 50[Ohm]) reference impedance of the S-matrix representing the TL section

    - dx –

      (default int(72)) dimensional step along the axis of the TL section that is used to solve the telegraphist’s ODE as well as the requested VI standing waves.

      If an int-like is given the intitial step is estimated as a 1/Nth of the wavelength along the transmission line.

      If a float-like is given it is taken as the dimensional step size. This initial estimate is refined so that an integer number of steps fits the TL section’s length.

      if a [floats]-like is given end points are added as necessary and the list is used as the node points along the TL. TODO: implement this.

    - odeparams – (default {‘rtol’:1E-12, ‘atol’:1E-12})

    - xpos – (default 0[m]) relative position of the first port of the TL section. useful to position VI standing waves on figures.

    - sNp – sNp-object (default=None) TODO: implement

  TL parameters can be given as:

  float-like

    just a constant value along the length of the TL section

  [floats]-like

    the TL section is split in len([floats])-1 segments that have a piece-wise linear varying value of the paramter (note: continuous). A list of 1 long is treated as a float-like

  [[floats],[floats]]-like

    the node positions are given in the first [floats] and their values in the second [floats]. The node positions do not need to start or end on the TL boundaries: the values are linarly interpolated or extrapolated to the nearest as the case may be.

  In case any of the supplied parameters are not constant the solving for the TL’s S-matrix and VI standing waves will invoke an ODE solver to solve the telegraphist’s equation. Otherwise the (constant) complex characteristic impedance and propagation constant is (derived form the supplied parameters and) used to explicitly solve the telegraphist’s equation.

  Global TL properties:

  > Z0TL: [Ohm] characteristic impedance of the TL

  > LTL: [H/m] line inductance of the TL CTL: [F/m] line capacitance of the TL

  > rTL: [Ohm/m] line resistance of the TL

  >   rTLO: [[Ohm/m] line resistance of the outer conductor of the TL rTLI: [Ohm/m] line resistance of the inner conductor of the TL

  > gTL: [Mho/m] medium conductance of the TL

  > A: [1/m] attenuation constant AdB: [dB/m] attenuation constant in dB/m

  Conductor properties:

  > rho: [Ohm.m] specific resistivity of the conductors

  >   rhoO: [Ohm.m] specific resistivity of the outer conductor rhoI: [Ohm.m] specific resistivity of the inner conductor

  > murO: [mu0] outer conductor’s permeability murI: [mu0] inner conductor’s permeability

  Medium properies:

  > sigma: [Mho/m] specific conductivity of the medium tand: [1] medium dielectric loss tangent

  > epsr: [epsilon0] medium’s relative permitivity mur: [mu0] medium’s relative permeability

  > etar: [eta0] medium’s relative impedance

  > vr: [c0] medium’s relative wave velocity

  Geometric properties:

  > OD: [m] outer diameter of a circular coaxial TL ID: [m] inner diameter of a circular coaxial TL

  > qTL: [1/m] rTL = (w rho mur mu0 / 2)**0.5 * qTL qTLO: [1/m] rTLO= (w rhoO murO mu0 / 2)**0.5 * qTLO qTLI: [1/m] rTLI = (w rhoI murI mu0 / 2)**0.5 * qTLI

  Implemented methods:

  __init__(**kwargs):

    performs the initial build of the TL section’s properties

  __str__:

    returns a nicely formated string describing the defined TL section

  __len__:

    (mandatory for RF objects) returns the number of ports

  set(**kwargs):

    (mandatory for RF objects) modifies some of the properties of the TL section

    currently implemented:

    > L for a constant TL section TODO: expand on the parameters and remove constant condition

  solveVI(f->float, [V0 -> np.complex, I0-> np.complex]): -> np.array

    solves the telegraphist’s equation either explicitly for constant TL sections or through an ODE solver otherwise. returns depending on the input parameters (see method)

  getS(fs, Zbase=None, params={})

    returns the S-matrix/ces for the requested frequency/ies [Hz] for the reference impedance Zbase (or the object’s reference impedance if not supplied). Prior to the evaluation the params-dict is passed to the object’s set method as **params.

  VISWs(f, E, Zbase=None)

    returns xs, (

  maxV(f, E, Zbase=None)

  VISWs(f, E, Zbase=None)
  asstr(full=False)
  copy()
  getS(fs, Zbase=None, params={}, **kw)

    returns an (array of) S-matrice(s) at the frequency(ies)fs

    Returns a single S-matrix for a float-like frequency fs [Hz] or a 1D array of S-matrices for a [floats]-like fs.

    The returned S-matrice(s) is(are) defined at the object’s reference impedance or at the supplied reference impedance Zbase.

    The object’s set function self.set(**kwargs) is called with **params prior to the evaluation.

  maxV(f, E, Zbase=None, ID='<top>', **kwargs)
  set(**kwargs)
  solveVI(f, V0=None, I0=None)

    Solves the telegraphist’s equation

    The telegraphist’s equation is solved for frequency f[Hz] either explicitly for a TL section with constant TL parameters or using scipy.integrate.odeint otherwise.

    The node points along the TL are defined through the atribute ‘dx’.

    TODO: for an int-like ‘dx’ and a non-constant TL section the estimation

      of the node points is not correctly implemented.

    Note: in the telegrapher’s equation the currents are flowing out of the

      ‘sink’ port (V0,I0) and into the ‘source’ port (would be V1=self.U[-1], I1= self.I[-1].

## pyRFtk.str_dict module

pyRFtk.str_dict.str_dict(adict)

## pyRFtk.tictoc module

pyRFtk.tictoc.tic()

pyRFtk.tictoc.toc(t0=None)

## pyRFtk.whoami module

pyRFtk.whoami.whoami(pname=None, dframe=1)

## Module contents