Esempio n. 1
0
        /// <summary>
        /// Execute the behaviour
        /// </summary>
        /// <param name="ckt">Circuit</param>
        public override void Load(Circuit ckt)
        {
            var    bsim2 = ComponentTyped <BSIM2>();
            var    model = bsim2.Model as BSIM2Model;
            var    state = ckt.State;
            var    rstate = state;
            var    method = ckt.Method;
            double EffectiveLength, DrainArea, SourceArea, DrainPerimeter, SourcePerimeter, DrainSatCurrent, SourceSatCurrent, GateSourceOverlapCap, GateDrainOverlapCap,
                   GateBulkOverlapCap, von, vdsat, vt0;
            int    Check;
            double vbs, vgs, vds, vbd, vgd, vgdo, delvbs, delvbd, delvgs, delvds, delvgd, cdhat, cbhat, vcrit, vgb, gbs, cbs, evbs, gbd, cbd,
                   evbd, cd, czbd, czbs, czbdsw, czbssw, PhiB, PhiBSW, MJ, MJSW, arg, argsw, sarg, sargsw, capbs = 0.0, capbd = 0.0;
            double ceqqg, gcdgb, gcsgb, gcggb, gcbgb, cqgate, cqbulk, cqdrn, ceqqb, ceqqd, ceqbs, ceqbd, xnrm, xrev, cdreq;
            double gm, gds, gmbs, qgate, qbulk, qdrn = 0.0, cggb, cgdb, cgsb, cbgb, cbdb, cbsb, cdgb = 0.0,
                   cddb = 0.0, cdsb = 0.0, cdrain, qsrc = 0.0, csgb = 0.0, cssb = 0.0, csdb = 0.0;
            double gcgdb, gcgsb, gcbdb, gcbsb, gcddb, gcdsb, gcsdb, gcssb;

            EffectiveLength = bsim2.B2l - model.B2deltaL * 1.0e-6; /* m */
            DrainArea       = bsim2.B2drainArea;
            SourceArea      = bsim2.B2sourceArea;
            DrainPerimeter  = bsim2.B2drainPerimeter;
            SourcePerimeter = bsim2.B2sourcePerimeter;
            if ((DrainSatCurrent = DrainArea * model.B2jctSatCurDensity) < 1e-15)
            {
                DrainSatCurrent = 1.0e-15;
            }
            if ((SourceSatCurrent = SourceArea * model.B2jctSatCurDensity) < 1.0e-15)
            {
                SourceSatCurrent = 1.0e-15;
            }
            GateSourceOverlapCap = model.B2gateSourceOverlapCap * bsim2.B2w;
            GateDrainOverlapCap  = model.B2gateDrainOverlapCap * bsim2.B2w;
            GateBulkOverlapCap   = model.B2gateBulkOverlapCap * EffectiveLength;
            von   = model.B2type * bsim2.B2von;
            vdsat = model.B2type * bsim2.B2vdsat;
            vt0   = model.B2type * bsim2.pParam.B2vt0;

            Check = 1;
            if (state.UseSmallSignal)
            {
                vbs = state.States[0][bsim2.B2states + BSIM2.B2vbs];
                vgs = state.States[0][bsim2.B2states + BSIM2.B2vgs];
                vds = state.States[0][bsim2.B2states + BSIM2.B2vds];
            }
            else if (state.Init == State.InitFlags.InitTransient)
            {
                vbs = state.States[1][bsim2.B2states + BSIM2.B2vbs];
                vgs = state.States[1][bsim2.B2states + BSIM2.B2vgs];
                vds = state.States[1][bsim2.B2states + BSIM2.B2vds];
            }
            else if (state.Init == State.InitFlags.InitJct && !bsim2.B2off)
            {
                vds = model.B2type * bsim2.B2icVDS;
                vgs = model.B2type * bsim2.B2icVGS;
                vbs = model.B2type * bsim2.B2icVBS;
                if ((vds == 0) && (vgs == 0) && (vbs == 0) &&
                    (method != null || state.UseDC || state.Domain == State.DomainTypes.None || !state.UseIC))
                {
                    vbs = -1;
                    vgs = vt0;
                    vds = 0;
                }
            }
            else if ((state.Init == State.InitFlags.InitJct || state.Init == State.InitFlags.InitFix) && bsim2.B2off)
            {
                vbs = vgs = vds = 0;
            }
            else
            {
                /* PREDICTOR */
                vbs = model.B2type * (rstate.OldSolution[bsim2.B2bNode] - rstate.OldSolution[bsim2.B2sNodePrime]);
                vgs = model.B2type * (rstate.OldSolution[bsim2.B2gNode] - rstate.OldSolution[bsim2.B2sNodePrime]);
                vds = model.B2type * (rstate.OldSolution[bsim2.B2dNodePrime] - rstate.OldSolution[bsim2.B2sNodePrime]);
                /* PREDICTOR */
                vbd    = vbs - vds;
                vgd    = vgs - vds;
                vgdo   = state.States[0][bsim2.B2states + BSIM2.B2vgs] - state.States[0][bsim2.B2states + BSIM2.B2vds];
                delvbs = vbs - state.States[0][bsim2.B2states + BSIM2.B2vbs];
                delvbd = vbd - state.States[0][bsim2.B2states + BSIM2.B2vbd];
                delvgs = vgs - state.States[0][bsim2.B2states + BSIM2.B2vgs];
                delvds = vds - state.States[0][bsim2.B2states + BSIM2.B2vds];
                delvgd = vgd - vgdo;

                if (bsim2.B2mode >= 0)
                {
                    cdhat = state.States[0][bsim2.B2states + BSIM2.B2cd] - state.States[0][bsim2.B2states + BSIM2.B2gbd] * delvbd + state.States[0][bsim2.B2states + BSIM2.B2gmbs] *
                            delvbs + state.States[0][bsim2.B2states + BSIM2.B2gm] * delvgs + state.States[0][bsim2.B2states + BSIM2.B2gds] * delvds;
                }
                else
                {
                    cdhat = state.States[0][bsim2.B2states + BSIM2.B2cd] - (state.States[0][bsim2.B2states + BSIM2.B2gbd] - state.States[0][bsim2.B2states + BSIM2.B2gmbs]) * delvbd -
                            state.States[0][bsim2.B2states + BSIM2.B2gm] * delvgd + state.States[0][bsim2.B2states + BSIM2.B2gds] * delvds;
                }
                cbhat = state.States[0][bsim2.B2states + BSIM2.B2cbs] + state.States[0][bsim2.B2states + BSIM2.B2cbd] + state.States[0][bsim2.B2states + BSIM2.B2gbd] * delvbd +
                        state.States[0][bsim2.B2states + BSIM2.B2gbs] * delvbs;

                /* NOBYPASS */

                von = model.B2type * bsim2.B2von;
                if (state.States[0][bsim2.B2states + BSIM2.B2vds] >= 0)
                {
                    vgs = Transistor.DEVfetlim(vgs, state.States[0][bsim2.B2states + BSIM2.B2vgs], von);
                    vds = vgs - vgd;
                    vds = Transistor.DEVlimvds(vds, state.States[0][bsim2.B2states + BSIM2.B2vds]);
                    vgd = vgs - vds;
                }
                else
                {
                    vgd = Transistor.DEVfetlim(vgd, vgdo, von);
                    vds = vgs - vgd;
                    vds = -Transistor.DEVlimvds(-vds, -(state.States[0][bsim2.B2states + BSIM2.B2vds]));
                    vgs = vgd + vds;
                }
                if (vds >= 0)
                {
                    vcrit = Circuit.CONSTvt0 * Math.Log(Circuit.CONSTvt0 / (Circuit.CONSTroot2 * SourceSatCurrent));
                    vbs   = Transistor.DEVpnjlim(vbs, state.States[0][bsim2.B2states + BSIM2.B2vbs], Circuit.CONSTvt0, vcrit, ref Check); /* bsim2.B2 test */
                    vbd   = vbs - vds;
                }
                else
                {
                    vcrit = Circuit.CONSTvt0 * Math.Log(Circuit.CONSTvt0 / (Circuit.CONSTroot2 * DrainSatCurrent));
                    vbd   = Transistor.DEVpnjlim(vbd, state.States[0][bsim2.B2states + BSIM2.B2vbd], Circuit.CONSTvt0, vcrit, ref Check); /* bsim2.B2 test */
                    vbs   = vbd + vds;
                }
            }

            /* determine DC current and derivatives */
            vbd = vbs - vds;
            vgd = vgs - vds;
            vgb = vgs - vbs;

            if (vbs <= 0.0)
            {
                gbs = SourceSatCurrent / Circuit.CONSTvt0 + state.Gmin;
                cbs = gbs * vbs;
            }
            else
            {
                evbs = Math.Exp(vbs / Circuit.CONSTvt0);
                gbs  = SourceSatCurrent * evbs / Circuit.CONSTvt0 + state.Gmin;
                cbs  = SourceSatCurrent * (evbs - 1) + state.Gmin * vbs;
            }
            if (vbd <= 0.0)
            {
                gbd = DrainSatCurrent / Circuit.CONSTvt0 + state.Gmin;
                cbd = gbd * vbd;
            }
            else
            {
                evbd = Math.Exp(vbd / Circuit.CONSTvt0);
                gbd  = DrainSatCurrent * evbd / Circuit.CONSTvt0 + state.Gmin;
                cbd  = DrainSatCurrent * (evbd - 1) + state.Gmin * vbd;
            }
            /* line 400 */
            if (vds >= 0)
            {
                /* normal mode */
                bsim2.B2mode = 1;
            }
            else
            {
                /* inverse mode */
                bsim2.B2mode = -1;
            }

            /* call bsim2.B2evaluate to calculate drain current and its
             * derivatives and charge and capacitances related to gate
             * drain, and bulk
             */
            if (vds >= 0)
            {
                bsim2.B2evaluate(vds, vbs, vgs, out gm, out gds, out gmbs, out qgate,
                                 out qbulk, out qdrn, out cggb, out cgdb, out cgsb, out cbgb, out cbdb, out cbsb, out cdgb,
                                 out cddb, out cdsb, out cdrain, out von, out vdsat, ckt);
            }
            else
            {
                bsim2.B2evaluate(-vds, vbd, vgd, out gm, out gds, out gmbs, out qgate,
                                 out qbulk, out qsrc, out cggb, out cgsb, out cgdb, out cbgb, out cbsb, out cbdb, out csgb,
                                 out cssb, out csdb, out cdrain, out von, out vdsat, ckt);
            }

            bsim2.B2von   = model.B2type * von;
            bsim2.B2vdsat = model.B2type * vdsat;

            /*
             * COMPUTE EQUIVALENT DRAIN CURRENT SOURCE
             */
            cd = bsim2.B2mode * cdrain - cbd;
            if (method != null || state.UseSmallSignal || (state.Domain == State.DomainTypes.Time && state.UseDC && state.UseIC))
            {
                /*
                 * charge storage elements
                 *
                 * bulk - drain and bulk - source depletion capacitances
                 * czbd : zero bias drain junction capacitance
                 * czbs : zero bias source junction capacitance
                 * czbdsw:zero bias drain junction sidewall capacitance
                 * czbssw:zero bias source junction sidewall capacitance
                 */

                czbd   = model.B2unitAreaJctCap * DrainArea;
                czbs   = model.B2unitAreaJctCap * SourceArea;
                czbdsw = model.B2unitLengthSidewallJctCap * DrainPerimeter;
                czbssw = model.B2unitLengthSidewallJctCap * SourcePerimeter;
                PhiB   = model.B2bulkJctPotential;
                PhiBSW = model.B2sidewallJctPotential;
                MJ     = model.B2bulkJctBotGradingCoeff;
                MJSW   = model.B2bulkJctSideGradingCoeff;

                /* Source Bulk Junction */
                if (vbs < 0)
                {
                    arg    = 1 - vbs / PhiB;
                    argsw  = 1 - vbs / PhiBSW;
                    sarg   = Math.Exp(-MJ * Math.Log(arg));
                    sargsw = Math.Exp(-MJSW * Math.Log(argsw));
                    state.States[0][bsim2.B2states + BSIM2.B2qbs] = PhiB * czbs * (1 - arg * sarg) / (1 - MJ) + PhiBSW * czbssw * (1 - argsw * sargsw) / (1 -
                                                                                                                                                          MJSW);
                    capbs = czbs * sarg + czbssw * sargsw;
                }
                else
                {
                    state.States[0][bsim2.B2states + BSIM2.B2qbs] = vbs * (czbs + czbssw) + vbs * vbs * (czbs * MJ * 0.5 / PhiB + czbssw * MJSW * 0.5 / PhiBSW);
                    capbs = czbs + czbssw + vbs * (czbs * MJ / PhiB + czbssw * MJSW / PhiBSW);
                }

                /* Drain Bulk Junction */
                if (vbd < 0)
                {
                    arg    = 1 - vbd / PhiB;
                    argsw  = 1 - vbd / PhiBSW;
                    sarg   = Math.Exp(-MJ * Math.Log(arg));
                    sargsw = Math.Exp(-MJSW * Math.Log(argsw));
                    state.States[0][bsim2.B2states + BSIM2.B2qbd] = PhiB * czbd * (1 - arg * sarg) / (1 - MJ) + PhiBSW * czbdsw * (1 - argsw * sargsw) / (1 -
                                                                                                                                                          MJSW);
                    capbd = czbd * sarg + czbdsw * sargsw;
                }
                else
                {
                    state.States[0][bsim2.B2states + BSIM2.B2qbd] = vbd * (czbd + czbdsw) + vbd * vbd * (czbd * MJ * 0.5 / PhiB + czbdsw * MJSW * 0.5 / PhiBSW);
                    capbd = czbd + czbdsw + vbd * (czbd * MJ / PhiB + czbdsw * MJSW / PhiBSW);
                }
            }

            /*
             * check convergence
             */
            if (!bsim2.B2off || state.Init != State.InitFlags.InitFix)
            {
                if (Check == 1)
                {
                    state.IsCon = false;
                }
            }
            state.States[0][bsim2.B2states + BSIM2.B2vbs]  = vbs;
            state.States[0][bsim2.B2states + BSIM2.B2vbd]  = vbd;
            state.States[0][bsim2.B2states + BSIM2.B2vgs]  = vgs;
            state.States[0][bsim2.B2states + BSIM2.B2vds]  = vds;
            state.States[0][bsim2.B2states + BSIM2.B2cd]   = cd;
            state.States[0][bsim2.B2states + BSIM2.B2cbs]  = cbs;
            state.States[0][bsim2.B2states + BSIM2.B2cbd]  = cbd;
            state.States[0][bsim2.B2states + BSIM2.B2gm]   = gm;
            state.States[0][bsim2.B2states + BSIM2.B2gds]  = gds;
            state.States[0][bsim2.B2states + BSIM2.B2gmbs] = gmbs;
            state.States[0][bsim2.B2states + BSIM2.B2gbd]  = gbd;
            state.States[0][bsim2.B2states + BSIM2.B2gbs]  = gbs;

            state.States[0][bsim2.B2states + BSIM2.B2cggb] = cggb;
            state.States[0][bsim2.B2states + BSIM2.B2cgdb] = cgdb;
            state.States[0][bsim2.B2states + BSIM2.B2cgsb] = cgsb;

            state.States[0][bsim2.B2states + BSIM2.B2cbgb] = cbgb;
            state.States[0][bsim2.B2states + BSIM2.B2cbdb] = cbdb;
            state.States[0][bsim2.B2states + BSIM2.B2cbsb] = cbsb;

            state.States[0][bsim2.B2states + BSIM2.B2cdgb] = cdgb;
            state.States[0][bsim2.B2states + BSIM2.B2cddb] = cddb;
            state.States[0][bsim2.B2states + BSIM2.B2cdsb] = cdsb;

            state.States[0][bsim2.B2states + BSIM2.B2capbs] = capbs;
            state.States[0][bsim2.B2states + BSIM2.B2capbd] = capbd;

            /* bulk and channel charge plus overlaps */

            if (method == null && ((!(state.Domain == State.DomainTypes.Time && state.UseDC)) || !state.UseIC) && !state.UseSmallSignal)
            {
                goto line850;
            }

            if (bsim2.B2mode > 0)
            {
                double[] args = new double[8];
                args[0] = GateDrainOverlapCap;
                args[1] = GateSourceOverlapCap;
                args[2] = GateBulkOverlapCap;
                args[3] = capbd;
                args[4] = capbs;
                args[5] = cggb;
                args[6] = cgdb;
                args[7] = cgsb;

                B2mosCap(ckt, vgd, vgs, vgb, args, cbgb, cbdb, cbsb, cdgb, cddb, cdsb,
                         out gcggb, out gcgdb, out gcgsb, out gcbgb, out gcbdb, out gcbsb, out gcdgb,
                         out gcddb, out gcdsb, out gcsgb, out gcsdb, out gcssb, ref qgate, ref qbulk,
                         ref qdrn, out qsrc);
            }
            else
            {
                double[] args = new double[8];
                args[0] = GateSourceOverlapCap;
                args[1] = GateDrainOverlapCap;
                args[2] = GateBulkOverlapCap;
                args[3] = capbs;
                args[4] = capbd;
                args[5] = cggb;
                args[6] = cgsb;
                args[7] = cgdb;

                B2mosCap(ckt, vgs, vgd, vgb, args, cbgb, cbsb, cbdb, csgb, cssb, csdb,
                         out gcggb, out gcgsb, out gcgdb, out gcbgb, out gcbsb, out gcbdb, out gcsgb,
                         out gcssb, out gcsdb, out gcdgb, out gcdsb, out gcddb, ref qgate, ref qbulk,
                         ref qsrc, out qdrn);
            }

            state.States[0][bsim2.B2states + BSIM2.B2qg] = qgate;
            state.States[0][bsim2.B2states + BSIM2.B2qd] = qdrn - state.States[0][bsim2.B2states + BSIM2.B2qbd];
            state.States[0][bsim2.B2states + BSIM2.B2qb] = qbulk + state.States[0][bsim2.B2states + BSIM2.B2qbd] + state.States[0][bsim2.B2states + BSIM2.B2qbs];

            /* store small signal parameters */
            if (method == null && (state.Domain == State.DomainTypes.Time && state.UseDC) && state.UseIC)
            {
                goto line850;
            }

            if (state.UseSmallSignal)
            {
                state.States[0][bsim2.B2states + BSIM2.B2cggb]  = cggb;
                state.States[0][bsim2.B2states + BSIM2.B2cgdb]  = cgdb;
                state.States[0][bsim2.B2states + BSIM2.B2cgsb]  = cgsb;
                state.States[0][bsim2.B2states + BSIM2.B2cbgb]  = cbgb;
                state.States[0][bsim2.B2states + BSIM2.B2cbdb]  = cbdb;
                state.States[0][bsim2.B2states + BSIM2.B2cbsb]  = cbsb;
                state.States[0][bsim2.B2states + BSIM2.B2cdgb]  = cdgb;
                state.States[0][bsim2.B2states + BSIM2.B2cddb]  = cddb;
                state.States[0][bsim2.B2states + BSIM2.B2cdsb]  = cdsb;
                state.States[0][bsim2.B2states + BSIM2.B2capbd] = capbd;
                state.States[0][bsim2.B2states + BSIM2.B2capbs] = capbs;

                goto line1000;
            }

            if (state.Init == State.InitFlags.InitTransient)
            {
                state.States[1][bsim2.B2states + BSIM2.B2qb] = state.States[0][bsim2.B2states + BSIM2.B2qb];
                state.States[1][bsim2.B2states + BSIM2.B2qg] = state.States[0][bsim2.B2states + BSIM2.B2qg];
                state.States[1][bsim2.B2states + BSIM2.B2qd] = state.States[0][bsim2.B2states + BSIM2.B2qd];
            }

            if (method != null)
            {
                method.Integrate(state, bsim2.B2states + BSIM2.B2qb, 0.0);
                method.Integrate(state, bsim2.B2states + BSIM2.B2qg, 0.0);
                method.Integrate(state, bsim2.B2states + BSIM2.B2qd, 0.0);
            }

            goto line860;

line850:
            /* initialize to zero charge conductance and current */
            ceqqg = ceqqb = ceqqd = 0.0;
            gcdgb = gcddb = gcdsb = 0.0;
            gcsgb = gcsdb = gcssb = 0.0;
            gcggb = gcgdb = gcgsb = 0.0;
            gcbgb = gcbdb = gcbsb = 0.0;
            goto line900;

line860:
            /* evaluate equivalent charge current */
            cqgate = state.States[0][bsim2.B2states + BSIM2.B2iqg];
            cqbulk = state.States[0][bsim2.B2states + BSIM2.B2iqb];
            cqdrn  = state.States[0][bsim2.B2states + BSIM2.B2iqd];
            ceqqg  = cqgate - gcggb * vgb + gcgdb * vbd + gcgsb * vbs;
            ceqqb  = cqbulk - gcbgb * vgb + gcbdb * vbd + gcbsb * vbs;
            ceqqd  = cqdrn - gcdgb * vgb + gcddb * vbd + gcdsb * vbs;

            if (state.Init == State.InitFlags.InitTransient)
            {
                state.States[1][bsim2.B2states + BSIM2.B2iqb] = state.States[0][bsim2.B2states + BSIM2.B2iqb];
                state.States[1][bsim2.B2states + BSIM2.B2iqg] = state.States[0][bsim2.B2states + BSIM2.B2iqg];
                state.States[1][bsim2.B2states + BSIM2.B2iqd] = state.States[0][bsim2.B2states + BSIM2.B2iqd];
            }

            /*
             * load current vector
             */
line900:

            ceqbs = model.B2type * (cbs - (gbs - state.Gmin) * vbs);
            ceqbd = model.B2type * (cbd - (gbd - state.Gmin) * vbd);

            ceqqg = model.B2type * ceqqg;
            ceqqb = model.B2type * ceqqb;
            ceqqd = model.B2type * ceqqd;
            if (bsim2.B2mode >= 0)
            {
                xnrm  = 1;
                xrev  = 0;
                cdreq = model.B2type * (cdrain - gds * vds - gm * vgs - gmbs * vbs);
            }
            else
            {
                xnrm  = 0;
                xrev  = 1;
                cdreq = -(model.B2type) * (cdrain + gds * vds - gm * vgd - gmbs * vbd);
            }

            // rstate.Rhs[bsim2.B2gNode] -= ceqqg;
            // rstate.Rhs[bsim2.B2bNode] -= (ceqbs + ceqbd + ceqqb);
            // rstate.Rhs[bsim2.B2dNodePrime] += (ceqbd - cdreq - ceqqd);
            // rstate.Rhs[bsim2.B2sNodePrime] += (cdreq + ceqbs + ceqqg + ceqqb + ceqqd);

            /*
             * load y matrix
             */

            // rstate.Matrix[bsim2.B2dNode, bsim2.B2dNode] += (bsim2.B2drainConductance);
            // rstate.Matrix[bsim2.B2gNode, bsim2.B2gNode] += (gcggb);
            // rstate.Matrix[bsim2.B2sNode, bsim2.B2sNode] += (bsim2.B2sourceConductance);
            // rstate.Matrix[bsim2.B2bNode, bsim2.B2bNode] += (gbd + gbs - gcbgb - gcbdb - gcbsb);
            // rstate.Matrix[bsim2.B2dNodePrime, bsim2.B2dNodePrime] += (bsim2.B2drainConductance + gds + gbd + xrev * (gm + gmbs) + gcddb);
            // rstate.Matrix[bsim2.B2sNodePrime, bsim2.B2sNodePrime] += (bsim2.B2sourceConductance + gds + gbs + xnrm * (gm + gmbs) + gcssb);
            // rstate.Matrix[bsim2.B2dNode, bsim2.B2dNodePrime] += (-bsim2.B2drainConductance);
            // rstate.Matrix[bsim2.B2gNode, bsim2.B2bNode] += (-gcggb - gcgdb - gcgsb);
            // rstate.Matrix[bsim2.B2gNode, bsim2.B2dNodePrime] += (gcgdb);
            // rstate.Matrix[bsim2.B2gNode, bsim2.B2sNodePrime] += (gcgsb);
            // rstate.Matrix[bsim2.B2sNode, bsim2.B2sNodePrime] += (-bsim2.B2sourceConductance);
            // rstate.Matrix[bsim2.B2bNode, bsim2.B2gNode] += (gcbgb);
            // rstate.Matrix[bsim2.B2bNode, bsim2.B2dNodePrime] += (-gbd + gcbdb);
            // rstate.Matrix[bsim2.B2bNode, bsim2.B2sNodePrime] += (-gbs + gcbsb);
            // rstate.Matrix[bsim2.B2dNodePrime, bsim2.B2dNode] += (-bsim2.B2drainConductance);
            // rstate.Matrix[bsim2.B2dNodePrime, bsim2.B2gNode] += ((xnrm - xrev) * gm + gcdgb);
            // rstate.Matrix[bsim2.B2dNodePrime, bsim2.B2bNode] += (-gbd + (xnrm - xrev) * gmbs - gcdgb - gcddb - gcdsb);
            // rstate.Matrix[bsim2.B2dNodePrime, bsim2.B2sNodePrime] += (-gds - xnrm * (gm + gmbs) + gcdsb);
            // rstate.Matrix[bsim2.B2sNodePrime, bsim2.B2gNode] += (-(xnrm - xrev) * gm + gcsgb);
            // rstate.Matrix[bsim2.B2sNodePrime, bsim2.B2sNode] += (-bsim2.B2sourceConductance);
            // rstate.Matrix[bsim2.B2sNodePrime, bsim2.B2bNode] += (-gbs - (xnrm - xrev) * gmbs - gcsgb - gcsdb - gcssb);
            // rstate.Matrix[bsim2.B2sNodePrime, bsim2.B2dNodePrime] += (-gds - xrev * (gm + gmbs) + gcsdb);

            line1000 :;
        }