public override void stamp(Circuit sim)
{
sim.stampNonLinear(lead_node[0]);
sim.stampNonLinear(lead_node[1]);
}
public override void stamp(Circuit sim)
{
sim.stampCurrentSource(lead_node[0], lead_node[1], sourceCurrent);
}
public override void step(Circuit sim)
{
double voltdiff = lead_volt[0] - lead_volt[1];
sim.stampCurrentSource(nodes[0], nodes[1], curSourceValue);
}
public override void step(Circuit sim)
{
double[] vs = new double[3];
vs[0] = lead_volt[0];
vs[1] = lead_volt[1];
vs[2] = lead_volt[2];
if (vs[1] > lastv1 + .5)
{
vs[1] = lastv1 + .5;
}
if (vs[1] < lastv1 - .5)
{
vs[1] = lastv1 - .5;
}
if (vs[2] > lastv2 + .5)
{
vs[2] = lastv2 + .5;
}
if (vs[2] < lastv2 - .5)
{
vs[2] = lastv2 - .5;
}
int source = 1;
int drain = 2;
if ((pnp ? -1 : 1) * vs[1] > (pnp ? -1 : 1) * vs[2])
{
source = 2;
drain = 1;
}
int gate = 0;
double vgs = vs[gate] - vs[source];
double vds = vs[drain] - vs[source];
if (Math.Abs(lastv1 - vs[1]) > .01 || Math.Abs(lastv2 - vs[2]) > .01)
{
sim.converged = false;
}
lastv1 = vs[1];
lastv2 = vs[2];
double realvgs = vgs;
double realvds = vds;
vgs *= (pnp ? -1 : 1);
vds *= (pnp ? -1 : 1);
ids = 0;
gm = 0;
double Gds = 0;
double beta = getBeta();
if (vgs > .5 && this is JfetElm)
{
sim.panic("JFET is reverse biased!", this);
return;
}
if (vgs < _threshold)
{
// should be all zero, but that causes a singular matrix,
// so instead we treat it as a large resistor
Gds = 1e-8;
ids = vds * Gds;
mode = 0;
}
else if (vds < vgs - _threshold)
{
// linear
ids = beta * ((vgs - _threshold) * vds - vds * vds * .5);
gm = beta * vds;
Gds = beta * (vgs - vds - _threshold);
mode = 1;
}
else
{
// saturation; Gds = 0
gm = beta * (vgs - _threshold);
// use very small Gds to avoid nonconvergence
Gds = 1e-8;
ids = 0.5 * beta * (vgs - _threshold) * (vgs - _threshold) + (vds - (vgs - _threshold)) * Gds;
mode = 2;
}
double rs = -(pnp ? -1 : 1) * ids + Gds * realvds + gm * realvgs;
sim.stampMatrix(lead_node[drain], lead_node[drain], Gds);
sim.stampMatrix(lead_node[drain], lead_node[source], -Gds - gm);
sim.stampMatrix(lead_node[drain], lead_node[gate], gm);
sim.stampMatrix(lead_node[source], lead_node[drain], -Gds);
sim.stampMatrix(lead_node[source], lead_node[source], Gds + gm);
sim.stampMatrix(lead_node[source], lead_node[gate], -gm);
sim.stampRightSide(lead_node[drain], rs);
sim.stampRightSide(lead_node[source], -rs);
if (source == 2 && (pnp ? -1 : 1) == 1 || source == 1 && (pnp ? -1 : 1) == -1)
{
ids = -ids;
}
}
public override void stamp(Circuit sim)
{
sim.stampVoltageSource(0, lead_node[1], voltSource);
}
/*public override double getPower() {
* return (lead_volt[0] - lead_volt[2]) * current;
* }*/
public override void step(Circuit sim)
{
double[] vs = new double[3];
vs[0] = lead_volt[0];
vs[1] = lead_volt[1];
vs[2] = lead_volt[2];
if (vs[1] > lastv1 + 0.5)
{
vs[1] = lastv1 + 0.5;
}
if (vs[1] < lastv1 - 0.5)
{
vs[1] = lastv1 - 0.5;
}
if (vs[2] > lastv2 + 0.5)
{
vs[2] = lastv2 + 0.5;
}
if (vs[2] < lastv2 - 0.5)
{
vs[2] = lastv2 - 0.5;
}
int grid = 1;
int cath = 2;
int plate = 0;
double vgk = vs[grid] - vs[cath];
double vpk = vs[plate] - vs[cath];
if (Math.Abs(lastv0 - vs[0]) > 0.01 || Math.Abs(lastv1 - vs[1]) > 0.01 || Math.Abs(lastv2 - vs[2]) > 0.01)
{
sim.converged = false;
}
lastv0 = vs[0];
lastv1 = vs[1];
lastv2 = vs[2];
double ids = 0;
double gm = 0;
double Gds = 0;
double ival = vgk + vpk / mu;
currentg = 0;
if (vgk > .01)
{
sim.stampResistor(lead_node[grid], lead_node[cath], gridCurrentR);
currentg = vgk / gridCurrentR;
}
if (ival < 0)
{
// should be all zero, but that causes a singular matrix,
// so instead we treat it as a large resistor
Gds = 1E-8;
ids = vpk * Gds;
}
else
{
ids = Math.Pow(ival, 1.5) / kg1;
double q = 1.5 * Math.Sqrt(ival) / kg1;
// gm = dids/dgk;
// Gds = dids/dpk;
Gds = q;
gm = q / mu;
}
currentp = ids;
currentc = ids + currentg;
double rs = -ids + Gds * vpk + gm * vgk;
sim.stampMatrix(lead_node[plate], lead_node[plate], Gds);
sim.stampMatrix(lead_node[plate], lead_node[cath], -Gds - gm);
sim.stampMatrix(lead_node[plate], lead_node[grid], gm);
sim.stampMatrix(lead_node[cath], lead_node[plate], -Gds);
sim.stampMatrix(lead_node[cath], lead_node[cath], Gds + gm);
sim.stampMatrix(lead_node[cath], lead_node[grid], -gm);
sim.stampRightSide(lead_node[plate], rs);
sim.stampRightSide(lead_node[cath], -rs);
}
public override void step(Circuit sim)
{
sim.stampCurrentSource(lead_node[0], lead_node[1], curSourceValue[0]);
sim.stampCurrentSource(lead_node[2], lead_node[3], curSourceValue[1]);
sim.stampCurrentSource(lead_node[3], lead_node[4], curSourceValue[2]);
}
public override void stamp(Circuit sim)
{
sim.stampResistor(lead_node[0], lead_node[1], resistance);
}
public override void execute(Circuit sim)
{
pins[0].value = pins[2].value ^ pins[3].value;
pins[1].value = pins[2].value && pins[3].value;
}
public override void step(Circuit sim)
{
diode.doStep(sim, lead_volt[0] - lead_volt[1]);
}
public override void stamp(Circuit sim)
{
diode.stamp(sim, lead_node[0], lead_node[1]);
}
