/// <summary> /// Load the Y-matrix and right-hand side vector for frequency domain analysis. /// </summary> /// <param name="simulation">The frequency simulation.</param> public void Load(FrequencySimulation simulation) { simulation.ThrowIfNull(nameof(simulation)); var omega = simulation.ComplexState.Laplace.Imaginary; var gdpr = ModelParameters.DrainConductance * BaseParameters.Area; var gspr = ModelParameters.SourceConductance * BaseParameters.Area; var gm = Gm; var gds = Gds; var ggs = Ggs; var xgs = CapGs * omega; var ggd = Ggd; var xgd = CapGd * omega; CDrainDrainPtr.Value += gdpr; CGateGatePtr.Value += new Complex(ggd + ggs, xgd + xgs); CSourceSourcePtr.Value += gspr; CDrainPrimeDrainPrimePtr.Value += new Complex(gdpr + gds + ggd, xgd); CSourcePrimeSourcePrimePtr.Value += new Complex(gspr + gds + gm + ggs, xgs); CDrainDrainPrimePtr.Value -= gdpr; CGateDrainPrimePtr.Value -= new Complex(ggd, xgd); CGateSourcePrimePtr.Value -= new Complex(ggs, xgs); CSourceSourcePrimePtr.Value -= gspr; CDrainPrimeDrainPtr.Value -= gdpr; CDrainPrimeGatePtr.Value += new Complex(-ggd + gm, -xgd); CDrainPrimeSourcePrimePtr.Value += (-gds - gm); CSourcePrimeGatePtr.Value -= new Complex(ggs + gm, xgs); CSourcePrimeSourcePtr.Value -= gspr; CSourcePrimeDrainPrimePtr.Value -= gds; }
/// <summary> /// Initializes the parameters. /// </summary> /// <param name="simulation">The frequency simulation.</param> public void InitializeParameters(FrequencySimulation simulation) { simulation.ThrowIfNull(nameof(simulation)); CalculateBaseCapacitances(); CalculateCapacitances(VoltageGs, VoltageDs, VoltageBs); CalculateMeyerCharges(VoltageGs, VoltageGs - VoltageDs); }
/// <summary> /// Calculate AC parameters /// </summary> /// <param name="simulation"></param> public void InitializeParameters(FrequencySimulation simulation) { simulation.ThrowIfNull(nameof(simulation)); var state = simulation.RealState; var vd = state.Solution[PosPrimeNode] - state.Solution[NegNode]; CalculateCapacitance(vd); }
/// <summary> /// Load the Y-matrix and right-hand side vector for frequency domain analysis. /// </summary> /// <param name="simulation">The frequency simulation.</param> public void Load(FrequencySimulation simulation) { simulation.ThrowIfNull(nameof(simulation)); var laplace = simulation.ComplexState.Laplace; var factor = Complex.Exp(-laplace * BaseParameters.Delay.Value); var admittance = BaseParameters.Admittance; CPos1Pos1Ptr.Value += admittance; CPos1Int1Ptr.Value -= admittance; CNeg1Ibr1Ptr.Value -= 1; CPos2Pos2Ptr.Value += admittance; CNeg2Ibr2Ptr.Value -= 1; CInt1Pos1Ptr.Value -= admittance; CInt1Int1Ptr.Value += admittance; CInt1Ibr1Ptr.Value += 1; CInt2Int2Ptr.Value += admittance; CInt2Ibr2Ptr.Value += 1; CIbr1Neg1Ptr.Value -= 1; CIbr1Pos2Ptr.Value -= factor; CIbr1Neg2Ptr.Value += factor; CIbr1Int1Ptr.Value += 1; CIbr1Ibr2Ptr.Value -= factor * BaseParameters.Impedance; CIbr2Pos1Ptr.Value -= factor; CIbr2Neg1Ptr.Value += factor; CIbr2Neg2Ptr.Value -= 1; CIbr2Int2Ptr.Value += 1; CIbr2Ibr1Ptr.Value -= factor * BaseParameters.Impedance; CPos2Int2Ptr.Value -= admittance; CInt2Pos2Ptr.Value -= admittance; }
/// <summary> /// Initializes the parameters. /// </summary> /// <param name="simulation">The frequency simulation.</param> public void InitializeParameters(FrequencySimulation simulation) { simulation.ThrowIfNull(nameof(simulation)); var vgs = Vgs; var vgd = Vgd; // Calculate charge storage elements var czgs = TempCapGs * BaseParameters.Area; var czgd = TempCapGd * BaseParameters.Area; var twop = TempGatePotential + TempGatePotential; var czgsf2 = czgs / ModelTemperature.F2; var czgdf2 = czgd / ModelTemperature.F2; if (vgs < CorDepCap) { var sarg = Math.Sqrt(1 - vgs / TempGatePotential); CapGs = czgs / sarg; } else { CapGs = czgsf2 * (ModelTemperature.F3 + vgs / twop); } if (vgd < CorDepCap) { var sarg = Math.Sqrt(1 - vgd / TempGatePotential); CapGd = czgd / sarg; } else { CapGd = czgdf2 * (ModelTemperature.F3 + vgd / twop); } }
/// <summary> /// Execute behavior for AC analysis /// </summary> /// <param name="simulation">Frequency-based simulation</param> public void Load(FrequencySimulation simulation) { simulation.ThrowIfNull(nameof(simulation)); // Load the Y-matrix CPosControlBranchPtr.Value += BaseParameters.Coefficient.Value; CNegControlBranchPtr.Value -= BaseParameters.Coefficient.Value; }
/// <summary> /// Load the Y-matrix and right-hand side vector for frequency domain analysis. /// </summary> /// <param name="simulation">The frequency simulation.</param> /// <exception cref="ArgumentNullException">simulation</exception> public void Load(FrequencySimulation simulation) { simulation.ThrowIfNull(nameof(simulation)); var cstate = simulation.ComplexState; int xnrm, xrev; if (Mode < 0) { xnrm = 0; xrev = 1; } else { xnrm = 1; xrev = 0; } // Charge oriented model parameters var effectiveLength = BaseParameters.Length - 2 * ModelParameters.LateralDiffusion; var gateSourceOverlapCap = ModelParameters.GateSourceOverlapCapFactor * BaseParameters.Width; var gateDrainOverlapCap = ModelParameters.GateDrainOverlapCapFactor * BaseParameters.Width; var gateBulkOverlapCap = ModelParameters.GateBulkOverlapCapFactor * effectiveLength; // Meyer"s model parameters var capgs = CapGs + CapGs + gateSourceOverlapCap; var capgd = CapGd + CapGd + gateDrainOverlapCap; var capgb = CapGb + CapGb + gateBulkOverlapCap; var xgs = capgs * cstate.Laplace.Imaginary; var xgd = capgd * cstate.Laplace.Imaginary; var xgb = capgb * cstate.Laplace.Imaginary; var xbd = CapBd * cstate.Laplace.Imaginary; var xbs = CapBs * cstate.Laplace.Imaginary; // Load Y-matrix CGateGatePtr.Value += new Complex(0.0, xgd + xgs + xgb); CBulkBulkPtr.Value += new Complex(CondBd + CondBs, xgb + xbd + xbs); CDrainPrimeDrainPrimePtr.Value += new Complex(DrainConductance + CondDs + CondBd + xrev * (Transconductance + TransconductanceBs), xgd + xbd); CSourcePrimeSourcePrimePtr.Value += new Complex(SourceConductance + CondDs + CondBs + xnrm * (Transconductance + TransconductanceBs), xgs + xbs); CGateBulkPtr.Value -= new Complex(0.0, xgb); CGateDrainPrimePtr.Value -= new Complex(0.0, xgd); CGateSourcePrimePtr.Value -= new Complex(0.0, xgs); CBulkGatePtr.Value -= new Complex(0.0, xgb); CBulkDrainPrimePtr.Value -= new Complex(CondBd, xbd); CBulkSourcePrimePtr.Value -= new Complex(CondBs, xbs); CDrainPrimeGatePtr.Value += new Complex((xnrm - xrev) * Transconductance, -xgd); CDrainPrimeBulkPtr.Value += new Complex(-CondBd + (xnrm - xrev) * TransconductanceBs, -xbd); CSourcePrimeGatePtr.Value -= new Complex((xnrm - xrev) * Transconductance, xgs); CSourcePrimeBulkPtr.Value -= new Complex(CondBs + (xnrm - xrev) * TransconductanceBs, xbs); CDrainDrainPtr.Value += DrainConductance; CSourceSourcePtr.Value += SourceConductance; CDrainDrainPrimePtr.Value -= DrainConductance; CSourceSourcePrimePtr.Value -= SourceConductance; CDrainPrimeDrainPtr.Value -= DrainConductance; CDrainPrimeSourcePrimePtr.Value -= CondDs + xnrm * (Transconductance + TransconductanceBs); CSourcePrimeSourcePtr.Value -= SourceConductance; CSourcePrimeDrainPrimePtr.Value -= CondDs + xrev * (Transconductance + TransconductanceBs); }
/// <summary> /// Execute behavior for AC analysis /// </summary> /// <param name="simulation">Frequency-based simulation</param> public void Load(FrequencySimulation simulation) { simulation.ThrowIfNull(nameof(simulation)); // NOTE: Spice 3f5's documentation is IXXXX POS NEG VALUE but in the code it is IXXXX NEG POS VALUE // I solved it by inverting the current when loading the rhs vector CPosPtr.Value -= FrequencyParameters.Phasor; CNegPtr.Value += FrequencyParameters.Phasor; }
/// <summary> /// Initialize AC parameters /// </summary> /// <param name="simulation">Frequency-based simulation</param> public void InitializeParameters(FrequencySimulation simulation) { simulation.ThrowIfNull(nameof(simulation)); var state = simulation.RealState; var vbe = VoltageBe; var vbc = VoltageBc; var vbx = ModelParameters.BipolarType * (state.Solution[BaseNode] - state.Solution[CollectorPrimeNode]); var vcs = ModelParameters.BipolarType * (state.Solution[SubstrateNode] - state.Solution[CollectorPrimeNode]); CalculateCapacitances(vbe, vbc, vbx, vcs); }
/// <summary> /// Execute behavior for AC analysis /// </summary> /// <param name="simulation">Frequency-based simulation</param> public void Load(FrequencySimulation simulation) { simulation.ThrowIfNull(nameof(simulation)); // Load Y-matrix CPosBranchPtr.Value += 1.0; CBranchPosPtr.Value += 1.0; CNegBranchPtr.Value -= 1.0; CBranchNegPtr.Value -= 1.0; CBranchControlBranchPtr.Value -= BaseParameters.Coefficient.Value; }
/// <summary> /// Execute behavior for AC analysis /// </summary> /// <param name="simulation">Frequency-based simulation</param> public void Load(FrequencySimulation simulation) { simulation.ThrowIfNull(nameof(simulation)); var state = simulation.ComplexState; var value = state.Laplace * Factor; // Load Y-matrix Branch1Branch2Ptr.Value -= value; Branch2Branch1Ptr.Value -= value; }
/// <summary> /// Execute behavior for AC analysis /// </summary> /// <param name="simulation">Frequency-based simulation</param> public void Load(FrequencySimulation simulation) { simulation.ThrowIfNull(nameof(simulation)); var cstate = simulation.ComplexState; var gcpr = ModelTemperature.CollectorConduct * BaseParameters.Area; var gepr = ModelTemperature.EmitterConduct * BaseParameters.Area; var gpi = ConductancePi; var gmu = ConductanceMu; Complex gm = Transconductance; var go = OutputConductance; var td = ModelTemperature.ExcessPhaseFactor; if (!td.Equals(0)) // Avoid computations { var arg = td * cstate.Laplace; gm = gm + go; gm = gm * Complex.Exp(-arg); gm = gm - go; } var gx = ConductanceX; var xcpi = CapBe * cstate.Laplace; var xcmu = CapBc * cstate.Laplace; var xcbx = CapBx * cstate.Laplace; var xccs = CapCs * cstate.Laplace; var xcmcb = Geqcb * cstate.Laplace; CCollectorCollectorPtr.Value += gcpr; CBaseBasePtr.Value += gx + xcbx; CEmitterEmitterPtr.Value += gepr; CCollectorPrimeCollectorPrimePtr.Value += gmu + go + gcpr + xcmu + xccs + xcbx; CBasePrimeBasePrimePtr.Value += gx + gpi + gmu + xcpi + xcmu + xcmcb; CEmitterPrimeEmitterPrimePtr.Value += gpi + gepr + gm + go + xcpi; CCollectorCollectorPrimePtr.Value += -gcpr; CBaseBasePrimePtr.Value += -gx; CEmitterEmitterPrimePtr.Value += -gepr; CCollectorPrimeCollectorPtr.Value += -gcpr; CCollectorPrimeBasePrimePtr.Value += -gmu + gm - xcmu; CCollectorPrimeEmitterPrimePtr.Value += -gm - go; CBasePrimeBasePtr.Value += -gx; CBasePrimeCollectorPrimePtr.Value += -gmu - xcmu - xcmcb; CBasePrimeEmitterPrimePtr.Value += -gpi - xcpi; CEmitterPrimeEmitterPtr.Value += -gepr; CEmitterPrimeCollectorPrimePtr.Value += -go + xcmcb; CEmitterPrimeBasePrimePtr.Value += -gpi - gm - xcpi - xcmcb; CSubstrateSubstratePtr.Value += xccs; CCollectorPrimeSubstratePtr.Value += -xccs; CSubstrateCollectorPrimePtr.Value += -xccs; CBaseCollectorPrimePtr.Value += -xcbx; CCollectorPrimeBasePtr.Value += -xcbx; }
/// <summary> /// Execute behavior for AC analysis /// </summary> /// <param name="simulation">Frequency-based simulation</param> public override void Load(FrequencySimulation simulation) { simulation.ThrowIfNull(nameof(simulation)); var state = simulation.ComplexState; var val = state.Laplace * _bp.Inductance.Value; PosBranchPtr.Value += 1.0; NegBranchPtr.Value -= 1.0; BranchNegPtr.Value -= 1.0; BranchPosPtr.Value += 1.0; BranchBranchPtr.Value -= val; }
/// <summary> /// Execute behavior for AC analysis /// </summary> /// <param name="simulation">Frequency-based simulation</param> public void Load(FrequencySimulation simulation) { simulation.ThrowIfNull(nameof(simulation)); var state = simulation.ComplexState; var val = state.Laplace * Capacitance; // Load the Y-matrix PosPosPtr.Value += val; NegNegPtr.Value += val; PosNegPtr.Value -= val; NegPosPtr.Value -= val; }
/// <summary> /// Execute behavior for AC analysis /// </summary> /// <param name="simulation">Frequency-based simulation</param> public void Load(FrequencySimulation simulation) { simulation.ThrowIfNull(nameof(simulation)); // Load Y-matrix CPosBranchPtr.Value += 1.0; CBranchPosPtr.Value += 1.0; CNegBranchPtr.Value -= 1.0; CBranchNegPtr.Value -= 1.0; // Load Rhs-vector CBranchPtr.Value += FrequencyParameters.Phasor; }
/// <summary> /// Load the Y-matrix and right-hand side vector for frequency domain analysis. /// </summary> /// <param name="simulation">The frequency simulation.</param> public void Load(FrequencySimulation simulation) { simulation.ThrowIfNull(nameof(simulation)); var laplace = simulation.ComplexState.Laplace; var factor = Complex.Exp(-laplace * BaseParameters.Delay); // Load the Y-matrix and RHS-vector CPosBranchPtr.Value += 1.0; CNegBranchPtr.Value -= 1.0; CBranchPosPtr.Value += 1.0; CBranchNegPtr.Value -= 1.0; CBranchControlPosPtr.Value -= factor; CBranchControlNegPtr.Value += factor; }
/// <summary> /// Load the Y-matrix and right-hand side vector for frequency domain analysis. /// </summary> /// <param name="simulation">The frequency simulation.</param> /// <exception cref="ArgumentNullException">simulation</exception> public void Load(FrequencySimulation simulation) { simulation.ThrowIfNull(nameof(simulation)); // Get the current state var currentState = CurrentState; var gNow = currentState ? ModelParameters.OnConductance : ModelParameters.OffConductance; // Load the Y-matrix PosPosPtr.Value += gNow; PosNegPtr.Value -= gNow; NegPosPtr.Value -= gNow; NegNegPtr.Value += gNow; }
/// <summary> /// Execute behavior for AC analysis /// </summary> /// <param name="simulation">Frequency-based simulation</param> public void Load(FrequencySimulation simulation) { simulation.ThrowIfNull(nameof(simulation)); var state = simulation.ComplexState; var gspr = ModelTemperature.Conductance * BaseParameters.Area; var geq = Conductance; var xceq = Capacitance * state.Laplace.Imaginary; // Load Y-matrix CPosPosPtr.Value += gspr; CNegNegPtr.Value += new Complex(geq, xceq); CPosPrimePosPrimePtr.Value += new Complex(geq + gspr, xceq); CPosPosPrimePtr.Value -= gspr; CNegPosPrimePtr.Value -= new Complex(geq, xceq); CPosPrimePosPtr.Value -= gspr; CPosPrimeNegPtr.Value -= new Complex(geq, xceq); }