/// <summary>
/// Calculates the Meyer capacitors.
/// </summary>
/// <param name="vgs">The VGS.</param>
/// <param name="vgd">The VGD.</param>
protected void CalculateMeyerCharges(double vgs, double vgd)
{
var von = ModelParameters.MosfetType * Von;
var vdsat = ModelParameters.MosfetType * SaturationVoltageDs;
var oxideCap = ModelParameters.OxideCapFactor * EffectiveLength * BaseParameters.Width;
/*
* calculate meyer's capacitors
*/
double icapgs, icapgd, icapgb;
if (Mode > 0)
{
Transistor.MeyerCharges(vgs, vgd, von, vdsat,
out icapgs, out icapgd, out icapgb, TempPhi, oxideCap);
}
else
{
Transistor.MeyerCharges(vgd, vgs, von, vdsat,
out icapgd, out icapgs, out icapgb, TempPhi, oxideCap);
}
CapGs = icapgs;
CapGd = icapgd;
CapGb = icapgb;
}
/// <summary>
/// Initialize AC parameters
/// </summary>
/// <param name="simulation"></param>
public override void InitializeParameters(FrequencySimulation simulation)
{
if (simulation == null)
{
throw new ArgumentNullException(nameof(simulation));
}
double arg, sarg, sargsw;
// Get voltages
var vbd = _load.VoltageBd;
var vbs = _load.VoltageBs;
var vgs = _load.VoltageGs;
var vds = _load.VoltageDs;
var vgd = vgs - vds;
var effectiveLength = _bp.Length - 2 * _mbp.LateralDiffusion;
var oxideCap = _modeltemp.OxideCapFactor * effectiveLength * _bp.Width;
/*
* now we do the hard part of the bulk - drain and bulk - source
* diode - we evaluate the non - linear capacitance and
* charge
*
* the basic equations are not hard, but the implementation
* is somewhat long in an attempt to avoid log / exponential
* evaluations
*/
/*
* charge storage elements
*
* .. bulk - drain and bulk - source depletion capacitances
*/
/* CAPBYPASS */
/* can't bypass the diode capacitance calculations */
/* CAPZEROBYPASS */
if (vbs < _temp.TempDepletionCap)
{
arg = 1 - vbs / _temp.TempBulkPotential;
/*
* the following block looks somewhat long and messy,
* but since most users use the default grading
* coefficients of .5, and sqrt is MUCH faster than an
* Math.Exp(Math.Log()) we use this special case code to buy time.
* (as much as 10% of total job time!)
*/
if (_mbp.BulkJunctionBotGradingCoefficient.Value.Equals(_mbp.BulkJunctionSideGradingCoefficient.Value))
{
if (_mbp.BulkJunctionBotGradingCoefficient.Value.Equals(0.5))
{
sarg = sargsw = 1 / Math.Sqrt(arg);
}
else
{
sarg = sargsw = Math.Exp(-_mbp.BulkJunctionBotGradingCoefficient * Math.Log(arg));
}
}
else
{
if (_mbp.BulkJunctionBotGradingCoefficient.Value.Equals(0.5))
{
sarg = 1 / Math.Sqrt(arg);
}
else
{
/* NOSQRT */
sarg = Math.Exp(-_mbp.BulkJunctionBotGradingCoefficient * Math.Log(arg));
}
if (_mbp.BulkJunctionSideGradingCoefficient.Value.Equals(0.5))
{
sargsw = 1 / Math.Sqrt(arg);
}
else
{
/* NOSQRT */
sargsw = Math.Exp(-_mbp.BulkJunctionSideGradingCoefficient * Math.Log(arg));
}
}
CapBs = _temp.CapBs * sarg + _temp.CapBsSidewall * sargsw;
}
else
{
CapBs = _temp.F2S + _temp.F3S * vbs;
}
/* can't bypass the diode capacitance calculations */
/* CAPZEROBYPASS */
if (vbd < _temp.TempDepletionCap)
{
arg = 1 - vbd / _temp.TempBulkPotential;
/*
* the following block looks somewhat long and messy,
* but since most users use the default grading
* coefficients of .5, and sqrt is MUCH faster than an
* Math.Exp(Math.Log()) we use this special case code to buy time.
* (as much as 10% of total job time!)
*/
if (_mbp.BulkJunctionBotGradingCoefficient.Value.Equals(0.5) && _mbp.BulkJunctionSideGradingCoefficient.Value.Equals(0.5))
{
sarg = sargsw = 1 / Math.Sqrt(arg);
}
else
{
if (_mbp.BulkJunctionBotGradingCoefficient.Value.Equals(0.5))
{
sarg = 1 / Math.Sqrt(arg);
}
else
{
/* NOSQRT */
sarg = Math.Exp(-_mbp.BulkJunctionBotGradingCoefficient * Math.Log(arg));
}
if (_mbp.BulkJunctionSideGradingCoefficient.Value.Equals(0.5))
{
sargsw = 1 / Math.Sqrt(arg);
}
else
{
/* NOSQRT */
sargsw = Math.Exp(-_mbp.BulkJunctionSideGradingCoefficient * Math.Log(arg));
}
}
/* NOSQRT */
CapBd = _temp.CapBd * sarg + _temp.CapBdSidewall * sargsw;
}
else
{
CapBd = _temp.F2D + vbd * _temp.F3D;
}
/*
* calculate meyer's capacitors
*/
/*
* new cmeyer - this just evaluates at the current time,
* expects you to remember values from previous time
* returns 1 / 2 of non-constant portion of capacitance
* you must add in the other half from previous time
* and the constant part
*/
double icapgs, icapgd, icapgb;
if (_load.Mode > 0)
{
Transistor.MeyerCharges(vgs, vgd, _mbp.MosfetType * _load.Von, _mbp.MosfetType * _load.SaturationVoltageDs,
out icapgs, out icapgd, out icapgb,
_temp.TempPhi, oxideCap);
}
else
{
Transistor.MeyerCharges(vgd, vgs, _mbp.MosfetType * _load.Von, _mbp.MosfetType * _load.SaturationVoltageDs,
out icapgd, out icapgs, out icapgb,
_temp.TempPhi, oxideCap);
}
CapGs = icapgs;
CapGd = icapgd;
CapGb = icapgb;
}
/// <summary>
/// Transient behavior
/// </summary>
/// <param name="simulation"></param>
public override void Transient(TimeSimulation simulation)
{
if (simulation == null)
{
throw new ArgumentNullException(nameof(simulation));
}
var state = simulation.RealState;
double sargsw;
var vbs = _load.VoltageBs;
var vbd = _load.VoltageBd;
var vgs = _load.VoltageGs;
var vgd = _load.VoltageGs - _load.VoltageDs;
var vgb = _load.VoltageGs - _load.VoltageBs;
var von = _mbp.MosfetType * _load.Von;
var vdsat = _mbp.MosfetType * _load.SaturationVoltageDs;
VoltageDs.Current = _load.VoltageDs;
VoltageBs.Current = vbs;
VoltageGs.Current = vgs;
double gbd = 0.0;
double cbd = 0.0;
double gbs = 0.0;
double cbs = 0.0;
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 oxideCap = _modeltemp.OxideCapFactor * effectiveLength * _bp.Width;
/*
* now we do the hard part of the bulk - drain and bulk - source
* diode - we evaluate the non - linear capacitance and
* charge
*
* the basic equations are not hard, but the implementation
* is somewhat long in an attempt to avoid log / exponential
* evaluations
*/
/*
* charge storage elements
*
* .. bulk - drain and bulk - source depletion capacitances
*/
if (vbs < _temp.TempDepletionCap)
{
double arg = 1 - vbs / _temp.TempBulkPotential, sarg;
/*
* the following block looks somewhat long and messy,
* but since most users use the default grading
* coefficients of .5, and sqrt is MUCH faster than an
* Math.Exp(Math.Log()) we use this special case code to buy time.
* (as much as 10% of total job time!)
*/
if (_mbp.BulkJunctionBotGradingCoefficient.Value.Equals(_mbp.BulkJunctionSideGradingCoefficient.Value))
{
if (_mbp.BulkJunctionBotGradingCoefficient.Value.Equals(0.5))
{
sarg = sargsw = 1 / Math.Sqrt(arg);
}
else
{
sarg = sargsw = Math.Exp(-_mbp.BulkJunctionBotGradingCoefficient * Math.Log(arg));
}
}
else
{
if (_mbp.BulkJunctionBotGradingCoefficient.Value.Equals(0.5))
{
sarg = 1 / Math.Sqrt(arg);
}
else
{
/* NOSQRT */
sarg = Math.Exp(-_mbp.BulkJunctionBotGradingCoefficient * Math.Log(arg));
}
if (_mbp.BulkJunctionSideGradingCoefficient.Value.Equals(0.5))
{
sargsw = 1 / Math.Sqrt(arg);
}
else
{
/* NOSQRT */
sargsw = Math.Exp(-_mbp.BulkJunctionSideGradingCoefficient * Math.Log(arg));
}
}
// NOSQRT
ChargeBs.Current = _temp.TempBulkPotential * (_temp.CapBs * (1 - arg * sarg) / (1 - _mbp.BulkJunctionBotGradingCoefficient) +
_temp.CapBsSidewall * (1 - arg * sargsw) / (1 - _mbp.BulkJunctionSideGradingCoefficient));
CapBs = _temp.CapBs * sarg + _temp.CapBsSidewall * sargsw;
}
else
{
ChargeBs.Current = _temp.F4S + vbs * (_temp.F2S + vbs * (_temp.F3S / 2));
CapBs = _temp.F2S + _temp.F3S * vbs;
}
if (vbd < _temp.TempDepletionCap)
{
double arg = 1 - vbd / _temp.TempBulkPotential, sarg;
/*
* the following block looks somewhat long and messy,
* but since most users use the default grading
* coefficients of .5, and sqrt is MUCH faster than an
* Math.Exp(Math.Log()) we use this special case code to buy time.
* (as much as 10% of total job time!)
*/
if (_mbp.BulkJunctionBotGradingCoefficient.Value.Equals(0.5) && _mbp.BulkJunctionSideGradingCoefficient.Value.Equals(0.5))
{
sarg = sargsw = 1 / Math.Sqrt(arg);
}
else
{
if (_mbp.BulkJunctionBotGradingCoefficient.Value.Equals(0.5))
{
sarg = 1 / Math.Sqrt(arg);
}
else
{
/* NOSQRT */
sarg = Math.Exp(-_mbp.BulkJunctionBotGradingCoefficient * Math.Log(arg));
}
if (_mbp.BulkJunctionSideGradingCoefficient.Value.Equals(0.5))
{
sargsw = 1 / Math.Sqrt(arg);
}
else
{
/* NOSQRT */
sargsw = Math.Exp(-_mbp.BulkJunctionSideGradingCoefficient * Math.Log(arg));
}
}
/* NOSQRT */
ChargeBd.Current = _temp.TempBulkPotential * (_temp.CapBd * (1 - arg * sarg) / (1 - _mbp.BulkJunctionBotGradingCoefficient) +
_temp.CapBdSidewall * (1 - arg * sargsw) / (1 - _mbp.BulkJunctionSideGradingCoefficient));
CapBd = _temp.CapBd * sarg + _temp.CapBdSidewall * sargsw;
}
else
{
ChargeBd.Current = _temp.F4D + vbd * (_temp.F2D + vbd * _temp.F3D / 2);
CapBd = _temp.F2D + vbd * _temp.F3D;
}
/* (above only excludes tranop, since we're only at this
* point if tran or tranop)
*/
/*
* calculate equivalent conductances and currents for
* depletion capacitors
*/
// integrate the capacitors and save results
ChargeBd.Integrate();
gbd += ChargeBd.Jacobian(CapBd);
cbd += ChargeBd.Derivative;
ChargeBs.Integrate();
gbs += ChargeBs.Jacobian(CapBs);
cbs += ChargeBs.Derivative;
/*
* calculate meyer's capacitors
*/
double icapgs, icapgd, icapgb;
if (_load.Mode > 0)
{
Transistor.MeyerCharges(vgs, vgd, von, vdsat,
out icapgs, out icapgd, out icapgb, _temp.TempPhi, oxideCap);
}
else
{
Transistor.MeyerCharges(vgd, vgs, von, vdsat,
out icapgd, out icapgs, out icapgb, _temp.TempPhi, oxideCap);
}
CapGs.Current = icapgs;
CapGd.Current = icapgd;
CapGb.Current = icapgb;
var vgs1 = VoltageGs[1];
var vgd1 = vgs1 - VoltageDs[1];
var vgb1 = vgs1 - VoltageBs[1];
var capgs = CapGs.Current + CapGs[1] + gateSourceOverlapCap;
var capgd = CapGd.Current + CapGd[1] + gateDrainOverlapCap;
var capgb = CapGb.Current + CapGb[1] + gateBulkOverlapCap;
/*
* store small - signal parameters (for meyer's model)
* all parameters already stored, so done...
*/
ChargeGs.Current = (vgs - vgs1) * capgs + ChargeGs[1];
ChargeGd.Current = (vgd - vgd1) * capgd + ChargeGd[1];
ChargeGb.Current = (vgb - vgb1) * capgb + ChargeGb[1];
/*
* calculate equivalent conductances and currents for
* meyer"s capacitors
*/
ChargeGs.Integrate();
var gcgs = ChargeGs.Jacobian(capgs);
var ceqgs = ChargeGs.RhsCurrent(gcgs, vgs);
ChargeGd.Integrate();
var gcgd = ChargeGd.Jacobian(capgd);
var ceqgd = ChargeGd.RhsCurrent(gcgd, vgd);
ChargeGb.Integrate();
var gcgb = ChargeGb.Jacobian(capgb);
var ceqgb = ChargeGb.RhsCurrent(gcgb, vgb);
/*
* store charge storage info for meyer's cap in lx table
*/
// Load current vector
var ceqbs = _mbp.MosfetType * (cbs - (gbs - state.Gmin) * vbs);
var ceqbd = _mbp.MosfetType * (cbd - (gbd - state.Gmin) * vbd);
GatePtr.Value -= _mbp.MosfetType * (ceqgs + ceqgb + ceqgd);
BulkPtr.Value -= ceqbs + ceqbd - _mbp.MosfetType * ceqgb;
DrainPrimePtr.Value += ceqbd + _mbp.MosfetType * ceqgd;
SourcePrimePtr.Value += ceqbs + _mbp.MosfetType * ceqgs;
// load Y-matrix
GateGatePtr.Value += gcgd + gcgs + gcgb;
BulkBulkPtr.Value += gbd + gbs + gcgb;
DrainPrimeDrainPrimePtr.Value += gbd + gcgd;
SourcePrimeSourcePrimePtr.Value += gbs + gcgs;
GateBulkPtr.Value -= gcgb;
GateDrainPrimePtr.Value -= gcgd;
GateSourcePrimePtr.Value -= gcgs;
BulkGatePtr.Value -= gcgb;
BulkDrainPrimePtr.Value -= gbd;
BulkSourcePrimePtr.Value -= gbs;
DrainPrimeGatePtr.Value += -gcgd;
DrainPrimeBulkPtr.Value += -gbd;
SourcePrimeGatePtr.Value += -gcgs;
SourcePrimeBulkPtr.Value += -gbs;
}
/// <summary>
/// Calculate initial states
/// </summary>
/// <param name="simulation">Simulation</param>
public override void GetDcState(TimeSimulation simulation)
{
if (simulation == null)
{
throw new ArgumentNullException(nameof(simulation));
}
double sargsw;
var vbs = _load.VoltageBs;
var vbd = _load.VoltageBd;
var vgs = _load.VoltageGs;
var vgd = _load.VoltageGs - _load.VoltageDs;
var vgb = _load.VoltageGs - _load.VoltageBs;
var von = _mbp.MosfetType * _load.Von;
var vdsat = _mbp.MosfetType * _load.SaturationVoltageDs;
VoltageDs.Current = _load.VoltageDs;
VoltageBs.Current = vbs;
VoltageGs.Current = vgs;
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 oxideCap = _modeltemp.OxideCapFactor * effectiveLength * _bp.Width;
/*
* now we do the hard part of the bulk - drain and bulk - source
* diode - we evaluate the non - linear capacitance and
* charge
*
* the basic equations are not hard, but the implementation
* is somewhat long in an attempt to avoid log / exponential
* evaluations
*/
/*
* charge storage elements
*
* .. bulk - drain and bulk - source depletion capacitances
*/
if (vbs < _temp.TempDepletionCap)
{
double arg = 1 - vbs / _temp.TempBulkPotential, sarg;
/*
* the following block looks somewhat long and messy,
* but since most users use the default grading
* coefficients of .5, and sqrt is MUCH faster than an
* Math.Exp(Math.Log()) we use this special case code to buy time.
* (as much as 10% of total job time!)
*/
if (_mbp.BulkJunctionBotGradingCoefficient.Value.Equals(_mbp.BulkJunctionSideGradingCoefficient))
{
if (_mbp.BulkJunctionBotGradingCoefficient.Value.Equals(0.5))
{
sarg = sargsw = 1 / Math.Sqrt(arg);
}
else
{
sarg = sargsw = Math.Exp(-_mbp.BulkJunctionBotGradingCoefficient * Math.Log(arg));
}
}
else
{
if (_mbp.BulkJunctionBotGradingCoefficient.Value.Equals(0.5))
{
sarg = 1 / Math.Sqrt(arg);
}
else
{
/* NOSQRT */
sarg = Math.Exp(-_mbp.BulkJunctionBotGradingCoefficient * Math.Log(arg));
}
if (_mbp.BulkJunctionSideGradingCoefficient.Value.Equals(0.5))
{
sargsw = 1 / Math.Sqrt(arg);
}
else
{
/* NOSQRT */
sargsw = Math.Exp(-_mbp.BulkJunctionSideGradingCoefficient * Math.Log(arg));
}
}
// NOSQRT
ChargeBs.Current = _temp.TempBulkPotential * (_temp.CapBs * (1 - arg * sarg) / (1 - _mbp.BulkJunctionBotGradingCoefficient) +
_temp.CapBsSidewall * (1 - arg * sargsw) / (1 - _mbp.BulkJunctionSideGradingCoefficient));
}
else
{
ChargeBs.Current = _temp.F4S + vbs * (_temp.F2S + vbs * (_temp.F3S / 2));
}
if (vbd < _temp.TempDepletionCap)
{
double arg = 1 - vbd / _temp.TempBulkPotential, sarg;
/*
* the following block looks somewhat long and messy,
* but since most users use the default grading
* coefficients of .5, and sqrt is MUCH faster than an
* Math.Exp(Math.Log()) we use this special case code to buy time.
* (as much as 10% of total job time!)
*/
if (_mbp.BulkJunctionBotGradingCoefficient.Value.Equals(0.5) && _mbp.BulkJunctionSideGradingCoefficient.Value.Equals(0.5))
{
sarg = sargsw = 1 / Math.Sqrt(arg);
}
else
{
if (_mbp.BulkJunctionBotGradingCoefficient.Value.Equals(0.5))
{
sarg = 1 / Math.Sqrt(arg);
}
else
{
/* NOSQRT */
sarg = Math.Exp(-_mbp.BulkJunctionBotGradingCoefficient * Math.Log(arg));
}
if (_mbp.BulkJunctionSideGradingCoefficient.Value.Equals(0.5))
{
sargsw = 1 / Math.Sqrt(arg);
}
else
{
/* NOSQRT */
sargsw = Math.Exp(-_mbp.BulkJunctionSideGradingCoefficient * Math.Log(arg));
}
}
/* NOSQRT */
ChargeBd.Current = _temp.TempBulkPotential * (_temp.CapBd * (1 - arg * sarg) / (1 - _mbp.BulkJunctionBotGradingCoefficient) +
_temp.CapBdSidewall * (1 - arg * sargsw) / (1 - _mbp.BulkJunctionSideGradingCoefficient));
}
else
{
ChargeBd.Current = _temp.F4D + vbd * (_temp.F2D + vbd * _temp.F3D / 2);
}
/*
* calculate meyer's capacitors
*/
double icapgs, icapgd, icapgb;
if (_load.Mode > 0)
{
Transistor.MeyerCharges(vgs, vgd, von, vdsat,
out icapgs, out icapgd, out icapgb, _temp.TempPhi, oxideCap);
}
else
{
Transistor.MeyerCharges(vgd, vgs, von, vdsat,
out icapgd, out icapgs, out icapgb, _temp.TempPhi, oxideCap);
}
CapGs.Current = icapgs;
CapGd.Current = icapgd;
CapGb.Current = icapgb;
var capgs = 2 * CapGs.Current + gateSourceOverlapCap;
var capgd = 2 * CapGd.Current + gateDrainOverlapCap;
var capgb = 2 * CapGb.Current + gateBulkOverlapCap;
/* TRANOP */
ChargeGs.Current = capgs * vgs;
ChargeGd.Current = capgd * vgd;
ChargeGb.Current = capgb * vgb;
}
/// <summary>
/// Transient behavior
/// </summary>
/// <param name="simulation">Time-based simulation</param>
public override void Transient(TimeSimulation simulation)
{
if (simulation == null)
{
throw new ArgumentNullException(nameof(simulation));
}
double sargsw;
var vbs = _load.VoltageBs;
var vbd = _load.VoltageBd;
var vgs = _load.VoltageGs;
var vds = _load.VoltageDs;
var vgd = _load.VoltageGs - _load.VoltageDs;
var vgb = _load.VoltageGs - _load.VoltageBs;
var von = _mbp.MosfetType * _load.Von;
var vdsat = _mbp.MosfetType * _load.SaturationVoltageDs;
_vds.Current = vds;
_vbs.Current = vbs;
_vgs.Current = vgs;
var gbd = 0.0;
var cbd = 0.0;
var gbs = 0.0;
var cbs = 0.0;
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 oxideCap = _mbp.OxideCapFactor * effectiveLength * _bp.Width;
/*
* now we do the hard part of the bulk - drain and bulk - source
* diode - we evaluate the non - linear capacitance and
* charge
*
* the basic equations are not hard, but the implementation
* is somewhat long in an attempt to avoid log / exponential
* evaluations
*/
/*
* charge storage elements
*
* .. bulk - drain and bulk - source depletion capacitances
*/
if (vbs < _temp.TempDepletionCap)
{
double arg = 1 - vbs / _temp.TempBulkPotential, sarg;
/*
* the following block looks somewhat long and messy,
* but since most users use the default grading
* coefficients of .5, and sqrt is MUCH faster than an
* Math.Exp(Math.Log()) we use this special case code to buy time.
* (as much as 10% of total job time!)
*/
if (_mbp.BulkJunctionBotGradingCoefficient.Value.Equals(_mbp.BulkJunctionSideGradingCoefficient))
{
if (_mbp.BulkJunctionBotGradingCoefficient.Value.Equals(0.5))
{
sarg = sargsw = 1 / Math.Sqrt(arg);
}
else
{
sarg = sargsw = Math.Exp(-_mbp.BulkJunctionBotGradingCoefficient * Math.Log(arg));
}
}
else
{
if (_mbp.BulkJunctionBotGradingCoefficient.Value.Equals(0.5))
{
sarg = 1 / Math.Sqrt(arg);
}
else
{
/* NOSQRT */
sarg = Math.Exp(-_mbp.BulkJunctionBotGradingCoefficient * Math.Log(arg));
}
if (_mbp.BulkJunctionSideGradingCoefficient.Value.Equals(0.5))
{
sargsw = 1 / Math.Sqrt(arg);
}
else
{
/* NOSQRT */
sargsw = Math.Exp(-_mbp.BulkJunctionSideGradingCoefficient * Math.Log(arg));
}
}
/* NOSQRT */
_qbs.Current = _temp.TempBulkPotential * (_temp.CapBs * (1 - arg * sarg) / (1 - _mbp.BulkJunctionBotGradingCoefficient) +
_temp.CapBsSidewall * (1 - arg * sargsw) / (1 - _mbp.BulkJunctionSideGradingCoefficient));
CapBs = _temp.CapBs * sarg + _temp.CapBsSidewall * sargsw;
}
else
{
_qbs.Current = _temp.F4S + vbs * (_temp.F2S + vbs * (_temp.F3S / 2));
CapBs = _temp.F2S + _temp.F3S * vbs;
}
if (vbd < _temp.TempDepletionCap)
{
double arg = 1 - vbd / _temp.TempBulkPotential, sarg;
/*
* the following block looks somewhat long and messy,
* but since most users use the default grading
* coefficients of .5, and sqrt is MUCH faster than an
* Math.Exp(Math.Log()) we use this special case code to buy time.
* (as much as 10% of total job time!)
*/
if (_mbp.BulkJunctionBotGradingCoefficient.Value.Equals(0.5) && _mbp.BulkJunctionSideGradingCoefficient.Value.Equals(0.5))
{
sarg = sargsw = 1 / Math.Sqrt(arg);
}
else
{
if (_mbp.BulkJunctionBotGradingCoefficient.Value.Equals(0.5))
{
sarg = 1 / Math.Sqrt(arg);
}
else
{
/* NOSQRT */
sarg = Math.Exp(-_mbp.BulkJunctionBotGradingCoefficient * Math.Log(arg));
}
if (_mbp.BulkJunctionSideGradingCoefficient.Value.Equals(0.5))
{
sargsw = 1 / Math.Sqrt(arg);
}
else
{
/* NOSQRT */
sargsw = Math.Exp(-_mbp.BulkJunctionSideGradingCoefficient * Math.Log(arg));
}
}
/* NOSQRT */
_qbd.Current = _temp.TempBulkPotential * (_temp.CapBd * (1 - arg * sarg) / (1 - _mbp.BulkJunctionBotGradingCoefficient) +
_temp.CapBdSidewall * (1 - arg * sargsw) / (1 - _mbp.BulkJunctionSideGradingCoefficient));
CapBd = _temp.CapBd * sarg + _temp.CapBdSidewall * sargsw;
}
else
{
_qbd.Current = _temp.F4D + vbd * (_temp.F2D + vbd * _temp.F3D / 2);
CapBd = _temp.F2D + vbd * _temp.F3D;
}
/* CAPZEROBYPASS */
/* (above only excludes tranop, since we're only at this
* point if tran or tranop)
*/
/*
* calculate equivalent conductances and currents for
* depletion capacitors
*/
/* integrate the capacitors and save results */
_qbd.Integrate();
gbd += _qbd.Jacobian(CapBd);
cbd += _qbd.Derivative;
_qbs.Integrate();
gbs += _qbs.Jacobian(CapBs);
cbs += _qbs.Derivative;
/*
* calculate meyer's capacitors
*/
/*
* new cmeyer - this just evaluates at the current time,
* expects you to remember values from previous time
* returns 1 / 2 of non - constant portion of capacitance
* you must add in the other half from previous time
* and the constant part
*/
double icapgs, icapgd, icapgb;
if (_load.Mode > 0)
{
Transistor.MeyerCharges(vgs, vgd, von, vdsat,
out icapgs, out icapgd, out icapgb, _temp.TempPhi, oxideCap);
}
else
{
Transistor.MeyerCharges(vgd, vgs, von, vdsat,
out icapgd, out icapgs, out icapgb, _temp.TempPhi, oxideCap);
}
_capgs.Current = icapgs;
_capgd.Current = icapgd;
_capgb.Current = icapgb;
var vgs1 = _vgs[1];
var vgd1 = vgs1 - _vds[1];
var vgb1 = vgs1 - _vbs[1];
var capgs = _capgs.Current + _capgs[1] + gateSourceOverlapCap;
var capgd = _capgd.Current + _capgd[1] + gateDrainOverlapCap;
var capgb = _capgb.Current + _capgb[1] + gateBulkOverlapCap;
_qgs.Current = (vgs - vgs1) * capgs + _qgs[1];
_qgd.Current = (vgd - vgd1) * capgd + _qgd[1];
_qgb.Current = (vgb - vgb1) * capgb + _qgb[1];
/*
* calculate equivalent conductances and currents for
* meyer"s capacitors
*/
_qgs.Integrate();
var gcgs = _qgs.Jacobian(capgs);
var ceqgs = _qgs.RhsCurrent(gcgs, vgs);
_qgd.Integrate();
var gcgd = _qgd.Jacobian(capgd);
var ceqgd = _qgd.RhsCurrent(gcgd, vgd);
_qgb.Integrate();
var gcgb = _qgb.Jacobian(capgb);
var ceqgb = _qgb.RhsCurrent(gcgb, vgb);
// Load current vector
var ceqbs = _mbp.MosfetType * (cbs - gbs * vbs);
var ceqbd = _mbp.MosfetType * (cbd - gbd * vbd);
GatePtr.Value -= _mbp.MosfetType * (ceqgs + ceqgb + ceqgd);
BulkPtr.Value -= ceqbs + ceqbd - _mbp.MosfetType * ceqgb;
DrainPrimePtr.Value += ceqbd + _mbp.MosfetType * ceqgd;
SourcePrimePtr.Value += ceqbs + _mbp.MosfetType * ceqgs;
// Load y matrix
GateGatePtr.Value += gcgd + gcgs + gcgb;
BulkBulkPtr.Value += gbd + gbs + gcgb;
DrainPrimeDrainPrimePtr.Value += gbd + gcgd;
SourcePrimeSourcePrimePtr.Value += gbs + gcgs;
GateBulkPtr.Value -= gcgb;
GateDrainPrimePtr.Value -= gcgd;
GateSourcePrimePtr.Value -= gcgs;
BulkGatePtr.Value -= gcgb;
BulkDrainPrimePtr.Value -= gbd;
BulkSourcePrimePtr.Value -= gbs;
DrainPrimeGatePtr.Value += -gcgd;
DrainPrimeBulkPtr.Value += -gbd;
SourcePrimeGatePtr.Value += -gcgs;
SourcePrimeBulkPtr.Value += -gbs;
}
/// <summary>
/// Transient behavior
/// </summary>
/// <param name="simulation">Time-based simulation</param>
public override void Transient(TimeSimulation simulation)
{
if (simulation == null)
{
throw new ArgumentNullException(nameof(simulation));
}
double arg, sarg, sargsw;
// Get voltages
var vbd = _load.VoltageBd;
var vbs = _load.VoltageBs;
var vgs = _load.VoltageGs;
var vds = _load.VoltageDs;
var vgd = vgs - vds;
var vgb = vgs - vbs;
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 oxideCap = _modeltemp.OxideCapFactor * effectiveLength * _bp.Width;
var gbd = 0.0;
var cbd = 0.0;
var gbs = 0.0;
var cbs = 0.0;
// Store these voltages
VoltageGs.Current = vgs;
VoltageDs.Current = vds;
VoltageBs.Current = vbs;
/*
* now we do the hard part of the bulk - drain and bulk - source
* diode - we evaluate the non - linear capacitance and
* charge
*
* the basic equations are not hard, but the implementation
* is somewhat long in an attempt to avoid log / exponential
* evaluations
*/
/*
* charge storage elements
*
* .. bulk - drain and bulk - source depletion capacitances
*/
/* CAPBYPASS */
/* can't bypass the diode capacitance calculations */
/* CAPZEROBYPASS */
if (vbs < _temp.TempDepletionCap)
{
arg = 1 - vbs / _temp.TempBulkPotential;
/*
* the following block looks somewhat long and messy,
* but since most users use the default grading
* coefficients of .5, and sqrt is MUCH faster than an
* Math.Exp(Math.Log()) we use this special case code to buy time.
* (as much as 10% of total job time!)
*/
if (_mbp.BulkJunctionBotGradingCoefficient.Value.Equals(_mbp.BulkJunctionSideGradingCoefficient.Value))
{
if (_mbp.BulkJunctionBotGradingCoefficient.Value.Equals(0.5))
{
sarg = sargsw = 1 / Math.Sqrt(arg);
}
else
{
sarg = sargsw = Math.Exp(-_mbp.BulkJunctionBotGradingCoefficient * Math.Log(arg));
}
}
else
{
if (_mbp.BulkJunctionBotGradingCoefficient.Value.Equals(0.5))
{
sarg = 1 / Math.Sqrt(arg);
}
else
{
/* NOSQRT */
sarg = Math.Exp(-_mbp.BulkJunctionBotGradingCoefficient * Math.Log(arg));
}
if (_mbp.BulkJunctionSideGradingCoefficient.Value.Equals(0.5))
{
sargsw = 1 / Math.Sqrt(arg);
}
else
{
/* NOSQRT */
sargsw = Math.Exp(-_mbp.BulkJunctionSideGradingCoefficient * Math.Log(arg));
}
}
/* NOSQRT */
ChargeBs.Current = _temp.TempBulkPotential * (_temp.CapBs * (1 - arg * sarg) / (1 - _mbp.BulkJunctionBotGradingCoefficient) +
_temp.CapBsSidewall * (1 - arg * sargsw) / (1 - _mbp.BulkJunctionSideGradingCoefficient));
CapBs = _temp.CapBs * sarg + _temp.CapBsSidewall * sargsw;
}
else
{
ChargeBs.Current = _temp.F4S + vbs * (_temp.F2S + vbs * (_temp.F3S / 2));
CapBs = _temp.F2S + _temp.F3S * vbs;
}
/* can't bypass the diode capacitance calculations */
/* CAPZEROBYPASS */
if (vbd < _temp.TempDepletionCap)
{
arg = 1 - vbd / _temp.TempBulkPotential;
/*
* the following block looks somewhat long and messy,
* but since most users use the default grading
* coefficients of .5, and sqrt is MUCH faster than an
* Math.Exp(Math.Log()) we use this special case code to buy time.
* (as much as 10% of total job time!)
*/
if (_mbp.BulkJunctionBotGradingCoefficient.Value.Equals(0.5) && _mbp.BulkJunctionSideGradingCoefficient.Value.Equals(0.5))
{
sarg = sargsw = 1 / Math.Sqrt(arg);
}
else
{
if (_mbp.BulkJunctionBotGradingCoefficient.Value.Equals(0.5))
{
sarg = 1 / Math.Sqrt(arg);
}
else
{
/* NOSQRT */
sarg = Math.Exp(-_mbp.BulkJunctionBotGradingCoefficient * Math.Log(arg));
}
if (_mbp.BulkJunctionSideGradingCoefficient.Value.Equals(0.5))
{
sargsw = 1 / Math.Sqrt(arg);
}
else
{
/* NOSQRT */
sargsw = Math.Exp(-_mbp.BulkJunctionSideGradingCoefficient * Math.Log(arg));
}
}
/* NOSQRT */
ChargeBd.Current = _temp.TempBulkPotential * (_temp.CapBd * (1 - arg * sarg) / (1 - _mbp.BulkJunctionBotGradingCoefficient) +
_temp.CapBdSidewall * (1 - arg * sargsw) / (1 - _mbp.BulkJunctionSideGradingCoefficient));
CapBd = _temp.CapBd * sarg + _temp.CapBdSidewall * sargsw;
}
else
{
ChargeBd.Current = _temp.F4D + vbd * (_temp.F2D + vbd * _temp.F3D / 2);
CapBd = _temp.F2D + vbd * _temp.F3D;
}
// integrate the capacitors and save results
ChargeBd.Integrate();
gbd += ChargeBd.Jacobian(CapBd);
cbd += ChargeBd.Derivative;
// NOTE: The derivative of Qbd should be added to Cd (drain current). Figure out a way later.
ChargeBs.Integrate();
gbs += ChargeBs.Jacobian(CapBs);
cbs += ChargeBs.Derivative;
/*
* calculate meyer's capacitors
*/
/*
* new cmeyer - this just evaluates at the current time,
* expects you to remember values from previous time
* returns 1 / 2 of non-constant portion of capacitance
* you must add in the other half from previous time
* and the constant part
*/
double icapgs, icapgd, icapgb;
if (_load.Mode > 0)
{
Transistor.MeyerCharges(vgs, vgd, _mbp.MosfetType * _load.Von, _mbp.MosfetType * _load.SaturationVoltageDs,
out icapgs, out icapgd, out icapgb,
_temp.TempPhi, oxideCap);
}
else
{
Transistor.MeyerCharges(vgd, vgs, _mbp.MosfetType * _load.Von, _mbp.MosfetType * _load.SaturationVoltageDs,
out icapgd, out icapgs, out icapgb,
_temp.TempPhi, oxideCap);
}
CapGs.Current = icapgs;
CapGd.Current = icapgd;
CapGb.Current = icapgb;
var vgs1 = VoltageGs[1];
var vgd1 = vgs1 - VoltageDs[1];
var vgb1 = vgs1 - VoltageBs[1];
var capgs = CapGs.Current + CapGs[1] + gateSourceOverlapCap;
var capgd = CapGd.Current + CapGd[1] + gateDrainOverlapCap;
var capgb = CapGb.Current + CapGb[1] + gateBulkOverlapCap;
ChargeGs.Current = (vgs - vgs1) * capgs + ChargeGs[1];
ChargeGd.Current = (vgd - vgd1) * capgd + ChargeGd[1];
ChargeGb.Current = (vgb - vgb1) * capgb + ChargeGb[1];
/* NOTE: We can't reset derivatives!
* if (capgs == 0)
* state.States[0][States + Cqgs] = 0;
* if (capgd == 0)
* state.States[0][States + Cqgd] = 0;
* if (capgb == 0)
* state.States[0][States + Cqgb] = 0;
*/
/* NOTE: The formula with the method.Slope is to make it work for nonlinear capacitances!
* The correct formula is: ceq = dQ/dt - geq * vq where geq = slope * dQ/dvq
* The formula in Spice 3f5 is: ceq = dQ/dt - slope * Q where it assumes a linear capacitance
* method.Integrate(state, out gcgs, out ceqgs, States + Qgs, capgs);
* method.Integrate(state, out gcgd, out ceqgd, States + Qgd, capgd);
* method.Integrate(state, out gcgb, out ceqgb, States + Qgb, capgb);
* ceqgs = ceqgs - gcgs * vgs + method.Slope * state.States[0][States + Qgs];
* ceqgd = ceqgd - gcgd * vgd + method.Slope * state.States[0][States + Qgd];
* ceqgb = ceqgb - gcgb * vgb + method.Slope * state.States[0][States + Qgb];
*/
ChargeGs.Integrate();
var gcgs = ChargeGs.Jacobian(capgs);
var ceqgs = ChargeGs.RhsCurrent(gcgs, vgs);
ChargeGd.Integrate();
var gcgd = ChargeGd.Jacobian(capgd);
var ceqgd = ChargeGd.RhsCurrent(gcgd, vgd);
ChargeGb.Integrate();
var gcgb = ChargeGb.Jacobian(capgb);
var ceqgb = ChargeGb.RhsCurrent(gcgb, vgb);
// Load current vector
var ceqbs = _mbp.MosfetType * (cbs - gbs * vbs);
var ceqbd = _mbp.MosfetType * (cbd - gbd * vbd);
GatePtr.Value -= _mbp.MosfetType * (ceqgs + ceqgb + ceqgd);
BulkPtr.Value -= ceqbs + ceqbd - _mbp.MosfetType * ceqgb;
DrainPrimePtr.Value += ceqbd + _mbp.MosfetType * ceqgd;
SourcePrimePtr.Value += ceqbs + _mbp.MosfetType * ceqgs;
// Load Y-matrix
GateGatePtr.Value += gcgd + gcgs + gcgb;
BulkBulkPtr.Value += gbd + gbs + gcgb;
DrainPrimeDrainPrimePtr.Value += gbd + gcgd;
SourcePrimeSourcePrimePtr.Value += gbs + gcgs;
GateBulkPtr.Value -= gcgb;
GateDrainPrimePtr.Value -= gcgd;
GateSourcePrimePtr.Value -= gcgs;
BulkGatePtr.Value -= gcgb;
BulkDrainPrimePtr.Value -= gbd;
BulkSourcePrimePtr.Value -= gbs;
DrainPrimeGatePtr.Value -= gcgd;
DrainPrimeBulkPtr.Value -= gbd;
SourcePrimeGatePtr.Value -= gcgs;
SourcePrimeBulkPtr.Value -= gbs;
}
/// <summary>
/// Calculate DC state variables
/// </summary>
/// <param name="simulation">Time-based simulation</param>
public override void GetDcState(TimeSimulation simulation)
{
if (simulation == null)
{
throw new ArgumentNullException(nameof(simulation));
}
double arg, sarg, sargsw;
// Get voltages
var vbd = _load.VoltageBd;
var vbs = _load.VoltageBs;
var vgs = _load.VoltageGs;
var vds = _load.VoltageDs;
var vgd = vgs - vds;
var vgb = vgs - vbs;
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 oxideCap = _modeltemp.OxideCapFactor * effectiveLength * _bp.Width;
if (vbs < _temp.TempDepletionCap)
{
arg = 1 - vbs / _temp.TempBulkPotential;
if (_mbp.BulkJunctionBotGradingCoefficient.Value.Equals(_mbp.BulkJunctionSideGradingCoefficient.Value))
{
if (_mbp.BulkJunctionBotGradingCoefficient.Value.Equals(0.5))
{
sarg = sargsw = 1 / Math.Sqrt(arg);
}
else
{
sarg = sargsw = Math.Exp(-_mbp.BulkJunctionBotGradingCoefficient * Math.Log(arg));
}
}
else
{
if (_mbp.BulkJunctionBotGradingCoefficient.Value.Equals(0.5))
{
sarg = 1 / Math.Sqrt(arg);
}
else
{
sarg = Math.Exp(-_mbp.BulkJunctionBotGradingCoefficient * Math.Log(arg));
}
if (_mbp.BulkJunctionSideGradingCoefficient.Value.Equals(0.5))
{
sargsw = 1 / Math.Sqrt(arg);
}
else
{
sargsw = Math.Exp(-_mbp.BulkJunctionSideGradingCoefficient * Math.Log(arg));
}
}
ChargeBs.Current = _temp.TempBulkPotential * (_temp.CapBs * (1 - arg * sarg) / (1 - _mbp.BulkJunctionBotGradingCoefficient) +
_temp.CapBsSidewall * (1 - arg * sargsw) / (1 - _mbp.BulkJunctionSideGradingCoefficient));
}
else
{
ChargeBs.Current = _temp.F4S + vbs * (_temp.F2S + vbs * (_temp.F3S / 2));
}
if (vbd < _temp.TempDepletionCap)
{
arg = 1 - vbd / _temp.TempBulkPotential;
if (_mbp.BulkJunctionBotGradingCoefficient.Value.Equals(0.5) && _mbp.BulkJunctionSideGradingCoefficient.Value.Equals(0.5))
{
sarg = sargsw = 1 / Math.Sqrt(arg);
}
else
{
if (_mbp.BulkJunctionBotGradingCoefficient.Value.Equals(0.5))
{
sarg = 1 / Math.Sqrt(arg);
}
else
{
sarg = Math.Exp(-_mbp.BulkJunctionBotGradingCoefficient * Math.Log(arg));
}
if (_mbp.BulkJunctionSideGradingCoefficient.Value.Equals(0.5))
{
sargsw = 1 / Math.Sqrt(arg);
}
else
{
sargsw = Math.Exp(-_mbp.BulkJunctionSideGradingCoefficient * Math.Log(arg));
}
}
ChargeBd.Current = _temp.TempBulkPotential * (_temp.CapBd * (1 - arg * sarg) / (1 - _mbp.BulkJunctionBotGradingCoefficient) +
_temp.CapBdSidewall * (1 - arg * sargsw) / (1 - _mbp.BulkJunctionSideGradingCoefficient));
}
else
{
ChargeBd.Current = _temp.F4D + vbd * (_temp.F2D + vbd * _temp.F3D / 2);
}
/*
* calculate meyer's capacitors
*/
double icapgs, icapgd, icapgb;
if (_load.Mode > 0)
{
Transistor.MeyerCharges(vgs, vgd, _mbp.MosfetType * _load.Von, _mbp.MosfetType * _load.SaturationVoltageDs,
out icapgs, out icapgd, out icapgb,
_temp.TempPhi, oxideCap);
}
else
{
Transistor.MeyerCharges(vgd, vgs, _mbp.MosfetType * _load.Von, _mbp.MosfetType * _load.SaturationVoltageDs,
out icapgd, out icapgs, out icapgb,
_temp.TempPhi, oxideCap);
}
CapGs.Current = icapgs;
CapGd.Current = icapgd;
CapGb.Current = icapgb;
var capgs = 2 * CapGs.Current + gateSourceOverlapCap;
var capgd = 2 * CapGd.Current + gateDrainOverlapCap;
var capgb = 2 * CapGb.Current + gateBulkOverlapCap;
/* TRANOP only */
ChargeGs.Current = vgs * capgs;
ChargeGd.Current = vgd * capgd;
ChargeGb.Current = vgb * capgb;
// Store these voltages
VoltageGs.Current = vgs;
VoltageDs.Current = vds;
VoltageBs.Current = vbs;
}