/// <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>
/// 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)
{
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>
/// Calculate AC parameters
/// </summary>
/// <param name="simulation"></param>
public override void InitializeParameters(FrequencySimulation simulation)
{
if (simulation == null)
{
throw new ArgumentNullException(nameof(simulation));
}
var state = simulation.RealState;
double capd;
double vd = state.Solution[_posPrimeNode] - state.Solution[_negNode];
// charge storage elements
var czero = _temp.TempJunctionCap * _bp.Area;
if (vd < _temp.TempDepletionCap)
{
var arg = 1 - vd / _mbp.JunctionPotential;
var sarg = Math.Exp(-_mbp.GradingCoefficient * Math.Log(arg));
capd = _mbp.TransitTime * _load.Conduct + czero * sarg;
}
else
{
var czof2 = czero / _modeltemp.F2;
capd = _mbp.TransitTime * _load.Conduct + czof2 * (_modeltemp.F3 + _mbp.GradingCoefficient * vd / _mbp.JunctionPotential);
}
Capacitance = capd;
}
/// <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>
/// 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>
/// 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>
/// Execute behavior for AC analysis
/// </summary>
/// <param name="simulation">Frequency-based simulation</param>
public override void Load(FrequencySimulation simulation)
{
if (simulation == null)
{
throw new ArgumentNullException(nameof(simulation));
}
var cstate = simulation.ComplexState;
int xnrm, xrev;
if (_load.Mode < 0)
{
xnrm = 0;
xrev = 1;
}
else
{
xnrm = 1;
xrev = 0;
}
// Meyer's model parameters
var effectiveLength = _bp.Length - 2 * _mbp.LateralDiffusion;
var gateSourceOverlapCap = _mbp.GateSourceOverlapCapFactor * _bp.Width;
var gateDrainOverlapCap = _mbp.GateDrainOverlapCapFactor * _bp.Width;
var gateBulkOverlapCap = _mbp.GateBulkOverlapCapFactor * effectiveLength;
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
GateGatePtr.Value += new Complex(0.0, xgd + xgs + xgb);
BulkBulkPtr.Value += new Complex(_load.CondBd + _load.CondBs, xgb + xbd + xbs);
DrainPrimeDrainPrimePtr.Value += new Complex(_temp.DrainConductance + _load.CondDs + _load.CondBd + xrev * (_load.Transconductance + _load.TransconductanceBs), xgd + xbd);
SourcePrimeSourcePrimePtr.Value += new Complex(_temp.SourceConductance + _load.CondDs + _load.CondBs + xnrm * (_load.Transconductance + _load.TransconductanceBs), xgs + xbs);
GateBulkPtr.Value -= new Complex(0.0, xgb);
GateDrainPrimePtrPtr.Value -= new Complex(0.0, xgd);
GateSourcePrimePtr.Value -= new Complex(0.0, xgs);
BulkGatePtr.Value -= new Complex(0.0, xgb);
BulkDrainPrimePtr.Value -= new Complex(_load.CondBd, xbd);
BulkSourcePrimePtr.Value -= new Complex(_load.CondBs, xbs);
DrainPrimeGatePtr.Value += new Complex((xnrm - xrev) * _load.Transconductance, -xgd);
DrainPrimeBulkPtr.Value += new Complex(-_load.CondBd + (xnrm - xrev) * _load.TransconductanceBs, -xbd);
SourcePrimeGatePtr.Value -= new Complex((xnrm - xrev) * _load.Transconductance, xgs);
SourcePrimeBulkPtr.Value -= new Complex(_load.CondBs + (xnrm - xrev) * _load.TransconductanceBs, xbs);
DrainDrainPtr.Value += _temp.DrainConductance;
SourceSourcePtr.Value += _temp.SourceConductance;
DrainDrainPrimePtr.Value -= _temp.DrainConductance;
SourceSourcePrimePtr.Value -= _temp.SourceConductance;
DrainPrimeDrainPtr.Value -= _temp.DrainConductance;
DrainPrimeSourcePrimePtr.Value -= _load.CondDs + xnrm * (_load.Transconductance + _load.TransconductanceBs);
SourcePrimeSourcePtr.Value -= _temp.SourceConductance;
SourcePrimeDrainPrimePtr.Value -= _load.CondDs + xrev * (_load.Transconductance + _load.TransconductanceBs);
}
/// <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>
/// Initialize parameters for AC analysis
/// </summary>
public virtual void InitializeParameters(FrequencySimulation simulation)
{
if (simulation == null)
{
throw new ArgumentNullException(nameof(simulation));
}
// Nothing to initialize by default
}
/// <summary>
/// Execute behavior for AC analysis
/// </summary>
/// <param name="simulation">Frequency-based simulation</param>
public void Load(FrequencySimulation simulation)
{
var conductance = Conductance;
CPosPosPtr.Value += conductance;
CNegNegPtr.Value += conductance;
CPosNegPtr.Value -= conductance;
CNegPosPtr.Value -= conductance;
}
/// <summary>
/// Execute behavior for AC analysis
/// </summary>
/// <param name="simulation">Frequency-based simulation</param>
public void Load(FrequencySimulation simulation)
{
var value = BaseParameters.Coefficient.Value;
CPosControlPosPtr.Value += value;
CPosControlNegPtr.Value -= value;
CNegControlPosPtr.Value -= value;
CNegControlNegPtr.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));
// 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>
/// Initializes the parameters.
/// </summary>
/// <param name="simulation">The frequency simulation.</param>
public void InitializeParameters(FrequencySimulation simulation)
{
if (simulation == null)
{
throw new ArgumentNullException(nameof(simulation));
}
CalculateBaseCapacitances();
CalculateCapacitances(VoltageGs, VoltageDs, VoltageBs);
CalculateMeyerCharges(VoltageGs, VoltageGs - VoltageDs);
}
/// <summary>
/// Execute behavior for AC analysis
/// </summary>
/// <param name="simulation">Frequency-based simulation</param>
public void Load(FrequencySimulation simulation)
{
if (simulation == null)
{
throw new ArgumentNullException(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)
{
if (simulation == null)
{
throw new ArgumentNullException(nameof(simulation));
}
var cstate = simulation.ComplexState;
var gcpr = _modeltemp.CollectorConduct * _bp.Area;
var gepr = _modeltemp.EmitterConduct * _bp.Area;
var gpi = _load.ConductancePi;
var gmu = _load.ConductanceMu;
Complex gm = _load.Transconductance;
var go = _load.OutputConductance;
var td = _modeltemp.ExcessPhaseFactor;
if (!td.Equals(0)) // Avoid computations
{
Complex arg = td * cstate.Laplace;
gm = gm + go;
gm = gm * Complex.Exp(-arg);
gm = gm - go;
}
var gx = _load.ConductanceX;
var xcpi = CapBe * cstate.Laplace;
var xcmu = CapBc * cstate.Laplace;
var xcbx = CapBx * cstate.Laplace;
var xccs = CapCs * cstate.Laplace;
var xcmcb = CondCb * cstate.Laplace;
CollectorCollectorPtr.Value += gcpr;
BaseBasePtr.Value += gx + xcbx;
EmitterEmitterPtr.Value += gepr;
CollectorPrimeCollectorPrimePtr.Value += gmu + go + gcpr + xcmu + xccs + xcbx;
BasePrimeBasePrimePtr.Value += gx + gpi + gmu + xcpi + xcmu + xcmcb;
EmitterPrimeEmitterPrimePtr.Value += gpi + gepr + gm + go + xcpi;
CollectorCollectorPrimePtr.Value += -gcpr;
BaseBasePrimePtr.Value += -gx;
EmitterEmitterPrimePtr.Value += -gepr;
CollectorPrimeCollectorPtr.Value += -gcpr;
CollectorPrimeBasePrimePtr.Value += -gmu + gm - xcmu;
CollectorPrimeEmitterPrimePtr.Value += -gm - go;
BasePrimeBasePtr.Value += -gx;
BasePrimeCollectorPrimePtr.Value += -gmu - xcmu - xcmcb;
BasePrimeEmitterPrimePtr.Value += -gpi - xcpi;
EmitterPrimeEmitterPtr.Value += -gepr;
EmitterPrimeCollectorPrimePtr.Value += -go + xcmcb;
EmitterPrimeBasePrimePtr.Value += -gpi - gm - xcpi - xcmcb;
SubstrateSubstratePtr.Value += xccs;
CollectorPrimeSubstratePtr.Value += -xccs;
SubstrateCollectorPrimePtr.Value += -xccs;
BaseCollectorPrimePtr.Value += -xcbx;
CollectorPrimeBasePtr.Value += -xcbx;
}
/// <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)
{
if (simulation == null)
{
throw new ArgumentNullException(nameof(simulation));
}
// Load the Y-matrix
CPosControlBranchPtr.Value += BaseParameters.Coefficient.Value;
CNegControlBranchPtr.Value -= BaseParameters.Coefficient.Value;
}
/// <summary>
/// Calculate AC parameters
/// </summary>
/// <param name="simulation"></param>
public void InitializeParameters(FrequencySimulation simulation)
{
if (simulation == null)
{
throw new ArgumentNullException(nameof(simulation));
}
var state = simulation.RealState;
var vd = state.Solution[PosPrimeNode] - state.Solution[NegNode];
CalculateCapacitance(vd);
}
/// <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 override void Load(FrequencySimulation simulation)
{
if (simulation == null)
{
throw new ArgumentNullException(nameof(simulation));
}
// Load the Y-matrix
PosControlBranchPtr.Value += _bp.Coefficient.Value;
NegControlBranchPtr.Value -= _bp.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 override void Load(FrequencySimulation simulation)
{
if (simulation == null)
{
throw new ArgumentNullException(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
PosPtr.Value -= _ac;
NegPtr.Value += _ac;
}
/// <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>
/// 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>
/// 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)
{
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>
/// Execute behavior for AC analysis
/// </summary>
/// <param name="simulation">Frequency-based simulation</param>
public void Load(FrequencySimulation simulation)
{
if (simulation == null)
{
throw new ArgumentNullException(nameof(simulation));
}
var state = simulation.ComplexState;
var value = state.Laplace * Factor;
// Load Y-matrix
Branch1Branch2Ptr.Value -= value;
Branch2Branch1Ptr.Value -= 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));
// 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 override void Load(FrequencySimulation simulation)
{
if (simulation == null)
{
throw new ArgumentNullException(nameof(simulation));
}
// Load Y-matrix
PosBranchPtr.Value += 1.0;
BranchPosPtr.Value += 1.0;
NegBranchPtr.Value -= 1.0;
BranchNegPtr.Value -= 1.0;
BranchControlPosPtr.Value -= _bp.Coefficient.Value;
BranchControlNegPtr.Value += _bp.Coefficient.Value;
}
