Beispiel #1
0
 def __init__(self, instanceName):
     cir.Element.__init__(self, instanceName)
     # Use junctions to model diodes and capacitors
     self.jif = SVJunction()
     self.jir = SVJunction()
     self.jile = Junction()
     self.jilc = Junction()
     # collector/emitter terminal numbers: may be re-mapped by
     # extrinsic device
     self._ct = 0
     self._et = 2
Beispiel #2
0
 def __init__(self, instanceName):
     cir.Element.__init__(self, instanceName)
     # Use junctions to model diodes and capacitors
     self.jif = SVJunction()
     self.jir = SVJunction()
     self.jile = Junction()
     self.jilc = Junction()
     # collector/emitter terminal numbers: may be re-mapped by
     # extrinsic device
     self._ct = 0
     self._et = 2
Beispiel #3
0
class SVBJTi(cir.Element):
    """
    State-variable-based Gummel-Poon intrinsic BJT model based

    This implementation based mainly on previous implementation in
    carrot and some equations from Pspice manual, with the addition of
    the state-variable definitions.
    
    Terminal order: 0 Collector, 1 Base, 2 Emitter, (3 Bulk, not included)::

                      
      C (0) o----,         4----o  E (2)
                  \       /
                   \     /
                  ---------
                      |
                      o 
   
                      B (1)

    Can be used for NPN or PNP transistors.

    Intrinsic Internal Topology
    +++++++++++++++++++++++++++

    The state variable formulation is achieved by replacing the BE and
    BC diodes (Ibf, Ibr) with state-variable based diodes. This
    requires two additional variables (nodes) but eliminates large
    positive exponentials from the model::

                                  Term : x2 
                      +--------------------------+
                      |                          |
                     /|\                        /^\ 
                    ( | ) gyr v2               ( | ) gyr vbc(x)
                     \V/                        \|/  
             tref     |                          |
                 ,----+--------------------------+ 
                 |    |                          |               
                 |   /^\                        /|\              
                 |  ( | ) gyr v1               ( | ) gyr vbe(x)  
                ---  \|/                        \V/  
                 V    |                          |
                      +--------------------------+
                                  Term : x1                
                                                  
    All currents/charges in the model are functions of voltages v3
    (x2) and v4 (x1). Note that vbc and vbe are now also functions of
    x1, x2.

    In addition we may need 2 additional nodes (plus reference) if rb
    is not zero: Bi for the internal base node and tib to measure the
    internal base current and calculate Rb(ib).

    1. If RB == 0::

                           +----------------+--o 0 (C)
                    -      |                |
                          /^\               |
                   v2    ( | ) ibc(x2)      |
                          \|/               |       
                    +      |               /|\       
           (B) 1 o---------+              ( | ) ice(x1,x2)
                    +      |               \V/      
                          /|\               |       
                   v1    ( | ) ibe(x1)      |
                          \V/               |
                    -      |                |
                           +----------------+--o 2 (E)

    2. If RB != 0::

                                     +----------------+--o 0 (C)
                                -    |                |
                                    /^\               |
                  gyr tib      v2  ( | ) ibc(x2)      |
                                    \|/               |       
                     ,---,      +    |               /|\       
         (B) 1 o----( --> )----------+ Term : Bi    ( | ) ice(x1,x2)
                     `---`      +    |               \V/      
                                    /|\               |       
                               v1  ( | ) ibe(x1)      |
                                    \V/               |
                                -    |                |
                   gyr v(1,Bi)       +----------------+--o 2 (E)
                                  
                      ,---,       
                 +---( <-- ) -----+
                 |    `---`       |
          tref   |                | ib/gyr
              ,--+                |
              |  |    ,---,       | Term : ib
              |  +---( --> )------+
              |       `---`       
             --- 
              V     gyr ib Rb(ib)
                                           
    Charge sources are connected between internal nodes defined
    above. If xcjc is not 1 but RB is zero, xcjc is ignored.
    """

    devType = "svbjt"
    
    paramDict = dict(
        cir.Element.tempItem,
        type = ('Type (npn or pnp)', '', str, 'npn'),
        isat = ('Transport saturation current', 'A', float, 1e-16),
        bf = ('Ideal maximum forward beta', '', float, 100.),
        nf = ('Forward current emission coefficient', '', float, 1.),
        vaf = ('Forward early voltage', 'V', float, 0.),
        ikf = ('Forward-beta high current roll-off knee current', 'A', 
               float, 0.),
        ise = ('Base-emitter leakage saturation current', 'A', float, 0.),
        ne = ('Base-emitter leakage emission coefficient', '', float, 1.5),
        br = ('Ideal maximum reverse beta', '', float, 1.),
        nr = ('Reverse current emission coefficient', '', float, 1.),
        var = ('Reverse early voltage', 'V', float, 0.),
        ikr = ('Corner for reverse-beta high current roll off', 'A', float, 0.),
        isc = ('Base collector leakage saturation current', 'A', float, 0.),
        nc = ('Base-collector leakage emission coefficient', '', float, 2.),
        rb = ('Zero bias base resistance', 'Ohm', float, 0.),
        rbm = ('Minimum base resistance', 'Ohm', float, 0.),
        irb = ('Current at which rb falls to half of rbm', 'A', float, 0.),
        eg = ('Badgap voltage', 'eV', float, 1.11),
        cje = ('Base emitter zero bias p-n capacitance', 'F', float, 0.),
        vje = ('Base emitter built in potential', 'V', float, 0.75),
        mje = ('Base emitter p-n grading factor', '', float, 0.33),
        cjc = ('Base collector zero bias p-n capacitance', 'F', float, 0.),
        vjc = ('Base collector built in potential', 'V', float, 0.75),
        mjc = ('Base collector p-n grading factor', '', float, 0.33),
        xcjc = ('Fraction of cbc connected internal to rb', '', float, 1.),
        fc = ('Forward bias depletion capacitor coefficient', '', float, 0.5),
        tf = ('Ideal forward transit time', 's', float, 0.),
        xtf = ('Transit time bias dependence coefficient', '', float, 0.),
        vtf = ('Transit time dependency on vbc', 'V', float, 0.),
        itf = ('Transit time dependency on ic', 'A', float, 0.),
        tr = ('Ideal reverse transit time', 's', float, 0.),
        xtb = ('Forward and reverse beta temperature coefficient', '', 
               float, 0.),
        xti = ('IS temperature effect exponent', '', float, 3.),
        tnom = ('Nominal temperature', 'C', float, 27.),
        area = ('Current multiplier', '', float, 1.)
        )

    def __init__(self, instanceName):
        cir.Element.__init__(self, instanceName)
        # Use junctions to model diodes and capacitors
        self.jif = SVJunction()
        self.jir = SVJunction()
        self.jile = Junction()
        self.jilc = Junction()
        # collector/emitter terminal numbers: may be re-mapped by
        # extrinsic device
        self._ct = 0
        self._et = 2

    def process_params(self):
        """
        Adjusts internal topology and makes preliminary calculations
        according to parameters.
        """
        # Define topology first. Add state variable nodes
        x2 = self.add_internal_term('x2','s.v.')
        x1 = self.add_internal_term('x1','s.v.')
        tref = self.add_reference_term()
        # Default configuration assumes rb == 0
        # ibe, vbe, ibc, vbc, ice 
        self.csOutPorts = [(1, self._et), (tref, x1), (1, self._ct), 
                           (tref, x2), (self._ct, self._et)]
        # Controling voltages are x1, x2
        self.controlPorts = [(x1, tref), (x2, tref)]
        # qbe, qbc
        self.qsOutPorts = [(1, self._et), (1, self._ct)]

        # Flag to signal if the extra charge Qbx is needed or not
        self._qbx = False
        # Default state-variable VCCSs
        self.linearVCCS = [((1, self._et), (x1, tref), glVar.gyr),
                           ((1, self._ct), (x2, tref), glVar.gyr)]
        if self.rb != 0.:
            # rb is not zero: add internal terminals
            tBi = self.add_internal_term('Bi', 'V') 
            tib = self.add_internal_term('ib', '{0} A'.format(glVar.gyr)) 
            # Add Linear VCCS for gyrator(s)
            self.linearVCCS = [((tBi, self._et), (x1, tref), glVar.gyr),
                               ((tBi, 0), (x2, tref), glVar.gyr),
                               ((1, tBi), (tib, tref), glVar.gyr),
                               ((tib, tref), (1, tBi), glVar.gyr)]
            # ibe, vbe, ibc, vbc, ice, Rb(ib) * ib
            self.csOutPorts = [(tBi, self._et), (tref, x1), (tBi, self._ct), 
                               (tref, x2), (self._ct, self._et), (tref, tib)]
            # Controling voltages are x1, x2 and gyrator port
            self.controlPorts = [(x1, tref), (x2, tref), (tib, tref)]
            # qbie, qbic
            self.qsOutPorts = [(tBi, self._et), (tBi, self._ct)]
            # Now check if Cjbc must be splitted (since rb != 0)
            if (self.cjc != 0.) and (self.xcjc < 1.):
                # add extra charge source
                self.qsOutPorts.append((1, self._ct))
                self._qbx = True
        
        # Make sure the guess is consistent
        self.vPortGuess = np.zeros(len(self.controlPorts))
#        # Try guess in active region
#        self.vPortGuess[0] = 100. # x1
#        self.vPortGuess[1] = -1.  # x2
#        if self.rb != 0.:
#            self.vPortGuess[2] = 1e-6 / glVar.gyr  # ib 
        # In principle we may not need any charge
        keepPorts = [ ]
        if self.cje + self.tf != 0.:
            # keep qbe
            keepPorts.append(self.qsOutPorts[0])
        if self.cjc + self.tr != 0.:
            # keep qbc, qbx (if any)
            if self._qbx:
                keepPorts += self.qsOutPorts[-2:]
            else:
                keepPorts.append(self.qsOutPorts[-1])
        self.qsOutPorts = keepPorts

        # keep track of how many output variables are needed
        self.ncurrents = len(self.csOutPorts)
        self.ncharges = len(self.qsOutPorts)

        # NPN or PNP 
        if self.type == 'pnp':
            self._typef = -1.
        else:
            self._typef = 1.

        # Calculate common variables
        # Absolute nominal temperature
        self.Tnomabs = self.tnom + const.T0
        self.egapn = self.eg - .000702 * (self.Tnomabs**2) \
            / (self.Tnomabs + 1108.)
        # jif produces if, cje
        self.jif.process_params(self.isat, self.nf, self.fc, self.cje, 
                                self.vje, self.mje, self.xti, self.eg, 
                                self.Tnomabs)
        # jir produces ir, cjc
        self.jir.process_params(self.isat, self.nr, self.fc, self.cjc, 
                                self.vjc, self.mjc, self.xti, self.eg, 
                                self.Tnomabs)
        if self.ise != 0.:
            # jile produces ile
            self.jile.process_params(self.ise, self.ne, 0, 0, 0, 0, 
                                     self.xti, self.eg, self.Tnomabs)
        if self.isc != 0.:
            # jilc produces ilc
            self.jilc.process_params(self.isc, self.nc, 0, 0, 0, 0, 
                                     self.xti, self.eg, self.Tnomabs)
        # Constants needed for rb(ib) calculation
        if self.irb != 0.:
            self._ck1 = 144. / self.irb / self.area /np.pi/np.pi
            self._ck2 = np.pi*np.pi * np.sqrt(self.irb * self.area) / 24.

    def set_temp_vars(self, temp):
        """
        Calculate temperature-dependent variables, given temp in deg. C
        """
        # Absolute temperature (note self.temp is in deg. C)
        self.Tabs = const.T0 + temp
        # Normalized temp
        self.tnratio = self.Tabs / self.Tnomabs
        tnXTB = pow(self.tnratio, self.xtb)
        # Thermal voltage
        self.vt = const.k * self.Tabs / const.q
        # Temperature-adjusted egap
        self.egap_t = self.eg - .000702 * (self.Tabs**2) / (self.Tabs + 1108.)
        # set temperature in juctions
        self.jif.set_temp_vars(self.Tabs, self.Tnomabs, self.vt, 
                               self.egapn, self.egap_t)
        self.jir.set_temp_vars(self.Tabs, self.Tnomabs, self.vt, 
                               self.egapn, self.egap_t)
        # Adjust ise and isc (which have different temperature variation)
        if self.ise != 0.:
            self.jile.set_temp_vars(self.Tabs, self.Tnomabs, self.vt, 
                                    self.egapn, self.egap_t)
            self.jile._t_is /= tnXTB
        if self.isc != 0.:
            self.jilc.set_temp_vars(self.Tabs, self.Tnomabs, self.vt, 
                                    self.egapn, self.egap_t)
            self.jilc._t_is /= tnXTB
        # Now some BJT-only variables
        self._bf_t = self.bf * tnXTB
        self._br_t = self.br * tnXTB
        

    def eval_cqs(self, vPort):
        """
        Calculates currents/charges

        Input is a vector may be one of the following, depending on
        parameter values::

          vPort = [xbe, xbc]
          vPort = [xbe, xbc, v4_i] (gyrator voltage, irb != 0)

        Output also depends on parameter values. Charges only present
        if parameters make them different than 0 (i.e., cje, tf, cjc,
        etc. are set to nonzero values)::
        
          iVec = [ibe, vbe, ibc, vbc, ice]
          iVec = [ibe, vbe, ibc, vbc, ice, gyr*ib*Rb] (rb != 0)

          qVec = [qbe, qbc]
          qVec = [qbe, qbc, qbx] (rb != 0 and cjc != 1)

        """
        # Invert state variables if needed
        vPort1 = self._typef * vPort

        # Calculate junctions currents and voltages
        (ibf, vbe) = self.jif.get_idvd(vPort1[0])
        (ibr, vbc) = self.jir.get_idvd(vPort1[1])
        if self.ise != 0.:
            ile = self.jile.get_id(vbe)
        else:
            ile = 0.
        if self.isc != 0.:
            ilc = self.jilc.get_id(vbc)
        else:
            ilc = 0.
        # Kqb
        q1m1 = 1.
        if self.var != 0.:
            q1m1 -= vbe / self.var
        if self.vaf != 0.:
            q1m1 -= vbc / self.vaf
        kqb = 1. / q1m1
        # We need extra checking to consider the following
        # possibilities to create the AD tape:
        # 
        # 1. both ikf and ikr are zero -> no tape generated
        # 2. One of them is nonzero but both ibf and ibr are zero -> want tape
        #    but only for the nonzero parameter
        if self.ikf + self.ikr != 0.:
            q2 = 0.
            if self.ikf != 0.:
                q2 += ibf / self.ikf 
            if self.ikr != 0.:
                q2 += ibr / self.ikr
            kqb *= .5 * (1. + np.sqrt(1. + 4. * q2))

        # Create output vector [ibe, ibc, ice, ...]
        iVec = np.zeros(self.ncurrents, dtype = type(ibf))
        qVec = np.zeros(self.ncharges, dtype = type(ibf))
        # ibe, vbe
        iVec[0] = ibf / self._bf_t + ile
        iVec[1] = glVar.gyr * vbe
        # ibc, vbc
        iVec[2] = ibr / self._br_t + ilc
        iVec[3] = glVar.gyr * vbc
        # ice
        iVec[4] = (ibf - ibr) / kqb

        # RB
        if self.rb != 0.:
            # Using gyrator
            # vPort1[2] not defined if rb == 0
            # ib has area effect included (removed by _ck1 and _ck2)
            ib = vPort1[2] * glVar.gyr
            if self.irb != 0.:
                ib1 = np.abs(ib)
                x = np.sqrt(1. + self._ck1 * ib1) - 1.
                x *= self._ck2 / np.sqrt(ib1)
                tx = np.tan(x)
                c = self.rbm + 3. * (self.rb - self.rbm) \
                    * (tx - x) / (x * tx * tx)
                rb = ad.condassign(ib1, c, self.rb)
            else:
                rb = self.rbm + (self.rb - self.rbm) / kqb
            # Output is gyr * ib * rb.  It is divided by area^2 to
            # compensate that the whole vector is multiplied by area
            # at the end
            iVec[5] = glVar.gyr * ib * rb / pow(self.area, 2)
            vbcx = ib * rb / self.area + vbc

        # Charges ----------------------------------------------- 

        # Note that if tf == 0 and cje == 0, nothing is calculated and
        # nothing is assigned to the output vector.

        # qbe is the first charge (0)
        if self.tf != 0.:
            # Effective tf
            tfeff = self.tf
            if self.vtf != 0.:
                x = ibf / (ibf + self.itf)
                # safe_exp() not needed since positive vbc grows
                # logarithmically
                tfeff *= (1. + self.xtf * x*x * 
                          np.exp(vbc /1.44 /self.vtf))
            qVec[0] = tfeff * ibf
        if self.cje != 0.:
            qVec[0] += self.jif.get_qd(vbe) 

        # qbc 
        if self._qbx:
            if self.tr != 0.:
                qVec[-2] = self.tr * ibr
            if self.cjc != 0.:
                qVec[-2] += self.jir.get_qd(vbc) * self.xcjc 
                # qbx
                qVec[-1] = self.jir.get_qd(vbcx) * (1. - self.xcjc)
        else:
            if self.tr != 0.:
                qVec[-1] = self.tr * ibr
            if self.cjc != 0.:
                qVec[-1] += self.jir.get_qd(vbc) 

        # Consider area effect and invert currents if needed
        iVec *= self.area * self._typef
        qVec *= self.area * self._typef

        return (iVec, qVec)


    def power(self, vPort, currV):
        """ 
        Calculate total instantaneous power 

        Input: control voltages as in eval_cqs() and currents from
        returned by eval_cqs()
        """
        # vce = vbe - vbc
        gyrvce = currV[1] - currV[3]
        if self.rb != 0.:
            # currV[5] = ib * Rb * gyr
            # vPort[2] = ib / gyr
            pRb = currV[5] * vPort[2]
        else:
            pRb = 0.

        # pout = ibe * vbie + ibc * vbic + vce * ice + pRb
        pout = (currV[0] * currV[1] + currV[2] * currV[3] 
                + currV[4] * gyrvce) / glVar.gyr + pRb

        return pout

    def get_OP(self, vPort):
        """
        Calculates operating point information

        Input: same as eval_cqs
        Output: dictionary with OP variables
        For now it is quite incomplete
        """
        # First we need the Jacobian
        (outV, jac) = self.eval_and_deriv(vPort)
        power = self.power(vPort, outV)

        # calculate gm, etc. in terms od jac for state-variable
        # formulation
        opDict = dict(
            VBE = outV[1] / glVar.gyr,
            VCE = (outV[1] - outV[3]) / glVar.gyr,
            IB = outV[0] + outV[2],
            IC = outV[4] - outV[2],
            IE = - outV[4] - outV[0],
            Temp = self.temp,
            Power = power,
            )
        return opDict

    def get_noise(self, f):
        """
        Return noise spectral density at frequency f
        
        Requires a previous call to get_OP() 

        Not implemented yet
        """
        return None
Beispiel #4
0
class SVBJTi(cir.Element):
    """
    State-variable-based Gummel-Poon intrinsic BJT model based

    This implementation based mainly on previous implementation in
    carrot and some equations from Pspice manual, with the addition of
    the state-variable definitions.
    
    Terminal order: 0 Collector, 1 Base, 2 Emitter, (3 Bulk, not included)::

                      
      C (0) o----,         4----o  E (2)
                  \       /
                   \     /
                  ---------
                      |
                      o 
   
                      B (1)

    Can be used for NPN or PNP transistors.

    Intrinsic Internal Topology
    +++++++++++++++++++++++++++

    The state variable formulation is achieved by replacing the BE and
    BC diodes (Ibf, Ibr) with state-variable based diodes. This
    requires two additional variables (nodes) but eliminates large
    positive exponentials from the model::

                                  Term : x2 
                      +--------------------------+
                      |                          |
                     /|\                        /^\ 
                    ( | ) gyr v2               ( | ) gyr vbc(x)
                     \V/                        \|/  
             tref     |                          |
                 ,----+--------------------------+ 
                 |    |                          |               
                 |   /^\                        /|\              
                 |  ( | ) gyr v1               ( | ) gyr vbe(x)  
                ---  \|/                        \V/  
                 V    |                          |
                      +--------------------------+
                                  Term : x1                
                                                  
    All currents/charges in the model are functions of voltages v3
    (x2) and v4 (x1). Note that vbc and vbe are now also functions of
    x1, x2.

    In addition we may need 2 additional nodes (plus reference) if rb
    is not zero: Bi for the internal base node and tib to measure the
    internal base current and calculate Rb(ib).

    1. If RB == 0::

                           +----------------+--o 0 (C)
                    -      |                |
                          /^\               |
                   v2    ( | ) ibc(x2)      |
                          \|/               |       
                    +      |               /|\       
           (B) 1 o---------+              ( | ) ice(x1,x2)
                    +      |               \V/      
                          /|\               |       
                   v1    ( | ) ibe(x1)      |
                          \V/               |
                    -      |                |
                           +----------------+--o 2 (E)

    2. If RB != 0::

                                     +----------------+--o 0 (C)
                                -    |                |
                                    /^\               |
                  gyr tib      v2  ( | ) ibc(x2)      |
                                    \|/               |       
                     ,---,      +    |               /|\       
         (B) 1 o----( --> )----------+ Term : Bi    ( | ) ice(x1,x2)
                     `---`      +    |               \V/      
                                    /|\               |       
                               v1  ( | ) ibe(x1)      |
                                    \V/               |
                                -    |                |
                   gyr v(1,Bi)       +----------------+--o 2 (E)
                                  
                      ,---,       
                 +---( <-- ) -----+
                 |    `---`       |
          tref   |                | ib/gyr
              ,--+                |
              |  |    ,---,       | Term : ib
              |  +---( --> )------+
              |       `---`       
             --- 
              V     gyr ib Rb(ib)
                                           
    Charge sources are connected between internal nodes defined
    above. If xcjc is not 1 but RB is zero, xcjc is ignored.
    """

    devType = "svbjt"

    paramDict = dict(
        cir.Element.tempItem,
        type=('Type (npn or pnp)', '', str, 'npn'),
        isat=('Transport saturation current', 'A', float, 1e-16),
        bf=('Ideal maximum forward beta', '', float, 100.),
        nf=('Forward current emission coefficient', '', float, 1.),
        vaf=('Forward early voltage', 'V', float, 0.),
        ikf=('Forward-beta high current roll-off knee current', 'A', float,
             0.),
        ise=('Base-emitter leakage saturation current', 'A', float, 0.),
        ne=('Base-emitter leakage emission coefficient', '', float, 1.5),
        br=('Ideal maximum reverse beta', '', float, 1.),
        nr=('Reverse current emission coefficient', '', float, 1.),
        var=('Reverse early voltage', 'V', float, 0.),
        ikr=('Corner for reverse-beta high current roll off', 'A', float, 0.),
        isc=('Base collector leakage saturation current', 'A', float, 0.),
        nc=('Base-collector leakage emission coefficient', '', float, 2.),
        rb=('Zero bias base resistance', 'Ohm', float, 0.),
        rbm=('Minimum base resistance', 'Ohm', float, 0.),
        irb=('Current at which rb falls to half of rbm', 'A', float, 0.),
        eg=('Badgap voltage', 'eV', float, 1.11),
        cje=('Base emitter zero bias p-n capacitance', 'F', float, 0.),
        vje=('Base emitter built in potential', 'V', float, 0.75),
        mje=('Base emitter p-n grading factor', '', float, 0.33),
        cjc=('Base collector zero bias p-n capacitance', 'F', float, 0.),
        vjc=('Base collector built in potential', 'V', float, 0.75),
        mjc=('Base collector p-n grading factor', '', float, 0.33),
        xcjc=('Fraction of cbc connected internal to rb', '', float, 1.),
        fc=('Forward bias depletion capacitor coefficient', '', float, 0.5),
        tf=('Ideal forward transit time', 's', float, 0.),
        xtf=('Transit time bias dependence coefficient', '', float, 0.),
        vtf=('Transit time dependency on vbc', 'V', float, 0.),
        itf=('Transit time dependency on ic', 'A', float, 0.),
        tr=('Ideal reverse transit time', 's', float, 0.),
        xtb=('Forward and reverse beta temperature coefficient', '', float,
             0.),
        xti=('IS temperature effect exponent', '', float, 3.),
        tnom=('Nominal temperature', 'C', float, 27.),
        area=('Current multiplier', '', float, 1.))

    def __init__(self, instanceName):
        cir.Element.__init__(self, instanceName)
        # Use junctions to model diodes and capacitors
        self.jif = SVJunction()
        self.jir = SVJunction()
        self.jile = Junction()
        self.jilc = Junction()
        # collector/emitter terminal numbers: may be re-mapped by
        # extrinsic device
        self._ct = 0
        self._et = 2

    def process_params(self):
        """
        Adjusts internal topology and makes preliminary calculations
        according to parameters.
        """
        # Define topology first. Add state variable nodes
        x2 = self.add_internal_term('x2', 's.v.')
        x1 = self.add_internal_term('x1', 's.v.')
        tref = self.add_reference_term()
        # Default configuration assumes rb == 0
        # ibe, vbe, ibc, vbc, ice
        self.csOutPorts = [(1, self._et), (tref, x1), (1, self._ct),
                           (tref, x2), (self._ct, self._et)]
        # Controling voltages are x1, x2
        self.controlPorts = [(x1, tref), (x2, tref)]
        # qbe, qbc
        self.qsOutPorts = [(1, self._et), (1, self._ct)]

        # Flag to signal if the extra charge Qbx is needed or not
        self._qbx = False
        # Default state-variable VCCSs
        self.linearVCCS = [((1, self._et), (x1, tref), glVar.gyr),
                           ((1, self._ct), (x2, tref), glVar.gyr)]
        if self.rb != 0.:
            # rb is not zero: add internal terminals
            tBi = self.add_internal_term('Bi', 'V')
            tib = self.add_internal_term('ib', '{0} A'.format(glVar.gyr))
            # Add Linear VCCS for gyrator(s)
            self.linearVCCS = [((tBi, self._et), (x1, tref), glVar.gyr),
                               ((tBi, 0), (x2, tref), glVar.gyr),
                               ((1, tBi), (tib, tref), glVar.gyr),
                               ((tib, tref), (1, tBi), glVar.gyr)]
            # ibe, vbe, ibc, vbc, ice, Rb(ib) * ib
            self.csOutPorts = [(tBi, self._et), (tref, x1), (tBi, self._ct),
                               (tref, x2), (self._ct, self._et), (tref, tib)]
            # Controling voltages are x1, x2 and gyrator port
            self.controlPorts = [(x1, tref), (x2, tref), (tib, tref)]
            # qbie, qbic
            self.qsOutPorts = [(tBi, self._et), (tBi, self._ct)]
            # Now check if Cjbc must be splitted (since rb != 0)
            if (self.cjc != 0.) and (self.xcjc < 1.):
                # add extra charge source
                self.qsOutPorts.append((1, self._ct))
                self._qbx = True

        # Make sure the guess is consistent
        self.vPortGuess = np.zeros(len(self.controlPorts))
        #        # Try guess in active region
        #        self.vPortGuess[0] = 100. # x1
        #        self.vPortGuess[1] = -1.  # x2
        #        if self.rb != 0.:
        #            self.vPortGuess[2] = 1e-6 / glVar.gyr  # ib
        # In principle we may not need any charge
        keepPorts = []
        if self.cje + self.tf != 0.:
            # keep qbe
            keepPorts.append(self.qsOutPorts[0])
        if self.cjc + self.tr != 0.:
            # keep qbc, qbx (if any)
            if self._qbx:
                keepPorts += self.qsOutPorts[-2:]
            else:
                keepPorts.append(self.qsOutPorts[-1])
        self.qsOutPorts = keepPorts

        # keep track of how many output variables are needed
        self.ncurrents = len(self.csOutPorts)
        self.ncharges = len(self.qsOutPorts)

        # NPN or PNP
        if self.type == 'pnp':
            self._typef = -1.
        else:
            self._typef = 1.

        # Calculate common variables
        # Absolute nominal temperature
        self.Tnomabs = self.tnom + const.T0
        self.egapn = self.eg - .000702 * (self.Tnomabs**2) \
            / (self.Tnomabs + 1108.)
        # jif produces if, cje
        self.jif.process_params(self.isat, self.nf, self.fc, self.cje,
                                self.vje, self.mje, self.xti, self.eg,
                                self.Tnomabs)
        # jir produces ir, cjc
        self.jir.process_params(self.isat, self.nr, self.fc, self.cjc,
                                self.vjc, self.mjc, self.xti, self.eg,
                                self.Tnomabs)
        if self.ise != 0.:
            # jile produces ile
            self.jile.process_params(self.ise, self.ne, 0, 0, 0, 0, self.xti,
                                     self.eg, self.Tnomabs)
        if self.isc != 0.:
            # jilc produces ilc
            self.jilc.process_params(self.isc, self.nc, 0, 0, 0, 0, self.xti,
                                     self.eg, self.Tnomabs)
        # Constants needed for rb(ib) calculation
        if self.irb != 0.:
            self._ck1 = 144. / self.irb / self.area / np.pi / np.pi
            self._ck2 = np.pi * np.pi * np.sqrt(self.irb * self.area) / 24.

    def set_temp_vars(self, temp):
        """
        Calculate temperature-dependent variables, given temp in deg. C
        """
        # Absolute temperature (note self.temp is in deg. C)
        self.Tabs = const.T0 + temp
        # Normalized temp
        self.tnratio = self.Tabs / self.Tnomabs
        tnXTB = pow(self.tnratio, self.xtb)
        # Thermal voltage
        self.vt = const.k * self.Tabs / const.q
        # Temperature-adjusted egap
        self.egap_t = self.eg - .000702 * (self.Tabs**2) / (self.Tabs + 1108.)
        # set temperature in juctions
        self.jif.set_temp_vars(self.Tabs, self.Tnomabs, self.vt, self.egapn,
                               self.egap_t)
        self.jir.set_temp_vars(self.Tabs, self.Tnomabs, self.vt, self.egapn,
                               self.egap_t)
        # Adjust ise and isc (which have different temperature variation)
        if self.ise != 0.:
            self.jile.set_temp_vars(self.Tabs, self.Tnomabs, self.vt,
                                    self.egapn, self.egap_t)
            self.jile._t_is /= tnXTB
        if self.isc != 0.:
            self.jilc.set_temp_vars(self.Tabs, self.Tnomabs, self.vt,
                                    self.egapn, self.egap_t)
            self.jilc._t_is /= tnXTB
        # Now some BJT-only variables
        self._bf_t = self.bf * tnXTB
        self._br_t = self.br * tnXTB

    def eval_cqs(self, vPort):
        """
        Calculates currents/charges

        Input is a vector may be one of the following, depending on
        parameter values::

          vPort = [xbe, xbc]
          vPort = [xbe, xbc, v4_i] (gyrator voltage, irb != 0)

        Output also depends on parameter values. Charges only present
        if parameters make them different than 0 (i.e., cje, tf, cjc,
        etc. are set to nonzero values)::
        
          iVec = [ibe, vbe, ibc, vbc, ice]
          iVec = [ibe, vbe, ibc, vbc, ice, gyr*ib*Rb] (rb != 0)

          qVec = [qbe, qbc]
          qVec = [qbe, qbc, qbx] (rb != 0 and cjc != 1)

        """
        # Invert state variables if needed
        vPort1 = self._typef * vPort

        # Calculate junctions currents and voltages
        (ibf, vbe) = self.jif.get_idvd(vPort1[0])
        (ibr, vbc) = self.jir.get_idvd(vPort1[1])
        if self.ise != 0.:
            ile = self.jile.get_id(vbe)
        else:
            ile = 0.
        if self.isc != 0.:
            ilc = self.jilc.get_id(vbc)
        else:
            ilc = 0.
        # Kqb
        q1m1 = 1.
        if self.var != 0.:
            q1m1 -= vbe / self.var
        if self.vaf != 0.:
            q1m1 -= vbc / self.vaf
        kqb = 1. / q1m1
        # We need extra checking to consider the following
        # possibilities to create the AD tape:
        #
        # 1. both ikf and ikr are zero -> no tape generated
        # 2. One of them is nonzero but both ibf and ibr are zero -> want tape
        #    but only for the nonzero parameter
        if self.ikf + self.ikr != 0.:
            q2 = 0.
            if self.ikf != 0.:
                q2 += ibf / self.ikf
            if self.ikr != 0.:
                q2 += ibr / self.ikr
            kqb *= .5 * (1. + np.sqrt(1. + 4. * q2))

        # Create output vector [ibe, ibc, ice, ...]
        iVec = np.zeros(self.ncurrents, dtype=type(ibf))
        qVec = np.zeros(self.ncharges, dtype=type(ibf))
        # ibe, vbe
        iVec[0] = ibf / self._bf_t + ile
        iVec[1] = glVar.gyr * vbe
        # ibc, vbc
        iVec[2] = ibr / self._br_t + ilc
        iVec[3] = glVar.gyr * vbc
        # ice
        iVec[4] = (ibf - ibr) / kqb

        # RB
        if self.rb != 0.:
            # Using gyrator
            # vPort1[2] not defined if rb == 0
            # ib has area effect included (removed by _ck1 and _ck2)
            ib = vPort1[2] * glVar.gyr
            if self.irb != 0.:
                ib1 = np.abs(ib)
                x = np.sqrt(1. + self._ck1 * ib1) - 1.
                x *= self._ck2 / np.sqrt(ib1)
                tx = np.tan(x)
                c = self.rbm + 3. * (self.rb - self.rbm) \
                    * (tx - x) / (x * tx * tx)
                rb = ad.condassign(ib1, c, self.rb)
            else:
                rb = self.rbm + (self.rb - self.rbm) / kqb
            # Output is gyr * ib * rb.  It is divided by area^2 to
            # compensate that the whole vector is multiplied by area
            # at the end
            iVec[5] = glVar.gyr * ib * rb / pow(self.area, 2)
            vbcx = ib * rb / self.area + vbc

        # Charges -----------------------------------------------

        # Note that if tf == 0 and cje == 0, nothing is calculated and
        # nothing is assigned to the output vector.

        # qbe is the first charge (0)
        if self.tf != 0.:
            # Effective tf
            tfeff = self.tf
            if self.vtf != 0.:
                x = ibf / (ibf + self.itf)
                # safe_exp() not needed since positive vbc grows
                # logarithmically
                tfeff *= (1. +
                          self.xtf * x * x * np.exp(vbc / 1.44 / self.vtf))
            qVec[0] = tfeff * ibf
        if self.cje != 0.:
            qVec[0] += self.jif.get_qd(vbe)

        # qbc
        if self._qbx:
            if self.tr != 0.:
                qVec[-2] = self.tr * ibr
            if self.cjc != 0.:
                qVec[-2] += self.jir.get_qd(vbc) * self.xcjc
                # qbx
                qVec[-1] = self.jir.get_qd(vbcx) * (1. - self.xcjc)
        else:
            if self.tr != 0.:
                qVec[-1] = self.tr * ibr
            if self.cjc != 0.:
                qVec[-1] += self.jir.get_qd(vbc)

        # Consider area effect and invert currents if needed
        iVec *= self.area * self._typef
        qVec *= self.area * self._typef

        return (iVec, qVec)

    def power(self, vPort, currV):
        """ 
        Calculate total instantaneous power 

        Input: control voltages as in eval_cqs() and currents from
        returned by eval_cqs()
        """
        # vce = vbe - vbc
        gyrvce = currV[1] - currV[3]
        if self.rb != 0.:
            # currV[5] = ib * Rb * gyr
            # vPort[2] = ib / gyr
            pRb = currV[5] * vPort[2]
        else:
            pRb = 0.

        # pout = ibe * vbie + ibc * vbic + vce * ice + pRb
        pout = (currV[0] * currV[1] + currV[2] * currV[3] +
                currV[4] * gyrvce) / glVar.gyr + pRb

        return pout

    def get_OP(self, vPort):
        """
        Calculates operating point information

        Input: same as eval_cqs
        Output: dictionary with OP variables
        For now it is quite incomplete
        """
        # First we need the Jacobian
        (outV, jac) = self.eval_and_deriv(vPort)
        power = self.power(vPort, outV)

        # calculate gm, etc. in terms od jac for state-variable
        # formulation
        opDict = dict(
            VBE=outV[1] / glVar.gyr,
            VCE=(outV[1] - outV[3]) / glVar.gyr,
            IB=outV[0] + outV[2],
            IC=outV[4] - outV[2],
            IE=-outV[4] - outV[0],
            Temp=self.temp,
            Power=power,
        )
        return opDict

    def get_noise(self, f):
        """
        Return noise spectral density at frequency f
        
        Requires a previous call to get_OP() 

        Not implemented yet
        """
        return None