public override void stamp(Circuit sim)
{
resistance1 = maxResistance * position;
resistance2 = maxResistance * (1 - position);
sim.stampResistor(lead_node[0], lead_node[2], resistance1);
sim.stampResistor(lead_node[2], lead_node[1], resistance2);
}
public override void stamp(Circuit sim)
{
sim.stampVoltageSource(lead_node[4], lead_node[0], voltSource1);
sim.stampVoltageSource(lead_node[5], lead_node[1], voltSource2);
sim.stampResistor(lead_node[2], lead_node[4], impedance);
sim.stampResistor(lead_node[3], lead_node[5], impedance);
}
public override void stamp(Circuit sim)
{
// stamp voltage divider to put ctl pin at 2/3 V
sim.stampResistor(lead_node[N_VIN], lead_node[N_CTL], 5000);
sim.stampResistor(lead_node[N_CTL], 0, 10000);
// output pin
sim.stampVoltageSource(0, lead_node[N_OUT], pins[N_OUT].voltSource);
// discharge pin
sim.stampNonLinear(lead_node[N_DIS]);
}
public override void step(Circuit sim)
{
open = (lead_volt[2] < 2.5);
resistance = (open) ? r_off : r_on;
sim.stampResistor(lead_node[3], lead_node[1], resistance);
sim.updateVoltageSource(0, lead_node[3], voltSource, lead_volt[0] > 2.5 ? 5 : 0);
}
public override void stamp(Circuit sim)
{
if (needsPullDown)
{
sim.stampResistor(lead_node[0], 0, 1E6);
}
}
public override void stamp(Circuit sim)
{
if (position == 0)
{
sim.stampResistor(lead_node[0], lead_node[1], _resistance);
}
//sim.stampVoltageSource(lead_node[0], lead_node[1], voltSource, 0);
}
public override void step(Circuit sim)
{
open = (lead_volt[3] < 2.5);
if (invert)
{
open = !open;
}
if (open)
{
sim.stampResistor(lead_node[0], lead_node[2], r_on);
sim.stampResistor(lead_node[0], lead_node[1], r_off);
}
else
{
sim.stampResistor(lead_node[0], lead_node[1], r_on);
sim.stampResistor(lead_node[0], lead_node[2], r_off);
}
}
public override void stamp(Circuit sim)
{
sim.stampNonLinear(lead_node[anode]);
sim.stampNonLinear(lead_node[cnode]);
sim.stampNonLinear(lead_node[gnode]);
sim.stampNonLinear(lead_node[inode]);
sim.stampResistor(lead_node[gnode], lead_node[cnode], cresistance);
diode.stamp(sim, lead_node[inode], lead_node[gnode]);
}
public override void step(Circuit sim)
{
open = (lead_volt[2] < 2.5);
if (invert)
{
open = !open;
}
resistance = (open) ? r_off : r_on;
sim.stampResistor(lead_node[0], lead_node[1], resistance);
}
public override void stamp(Circuit sim) {
// output pin
sim.stampVoltageSource(0, lead_node[1], pins[1].voltSource);
// attach Vi to R1 pin so its current is proportional to Vi
sim.stampVoltageSource(lead_node[0], lead_node[4], pins[4].voltSource, 0);
// attach 5V to R2 pin so we get a current going
sim.stampVoltageSource(0, lead_node[5], pins[5].voltSource, 5);
// put resistor across cap pins to give current somewhere to go
// in case cap is not connected
sim.stampResistor(lead_node[2], lead_node[3], cResistance);
sim.stampNonLinear(lead_node[2]);
sim.stampNonLinear(lead_node[3]);
}
public override void step(Circuit sim)
{
// if output is low, discharge pin 0. we use a small
// resistor because it's easier, and sometimes people tie
// the discharge pin to the trigger and threshold pins.
// We check setOut to properly emulate the case where
// trigger is low and threshold is high.
if (!@out && !setOut)
{
sim.stampResistor(lead_node[N_DIS], 0, 10);
}
// output
sim.updateVoltageSource(0, lead_node[N_OUT], pins[N_OUT].voltSource, @out ? lead_volt[N_VIN] : 0);
}
public override void stamp(Circuit sim)
{
nodes[0] = lead_node[0];
nodes[1] = lead_node[1];
if (isTrapezoidal)
{
compResistance = 2 * inductance / sim.timeStep;
}
else
{
compResistance = inductance / sim.timeStep; // backward euler
}
sim.stampResistor(nodes[0], nodes[1], compResistance);
sim.stampRightSide(nodes[0]);
sim.stampRightSide(nodes[1]);
}
public override void step(Circuit sim)
{
double vac = lead_volt[anode] - lead_volt[cnode]; // typically negative
double vag = lead_volt[anode] - lead_volt[gnode]; // typically positive
if (Math.Abs(vac - lastvac) > 0.01 || Math.Abs(vag - lastvag) > .01)
{
sim.converged = false;
}
lastvac = vac;
lastvag = vag;
diode.doStep(sim, lead_volt[inode] - lead_volt[gnode]);
double icmult = 1 / triggerI;
double iamult = 1 / holdingI - icmult;
aresistance = (-icmult * ic + ia * iamult > 1) ? 0.0105 : 10E5;
sim.stampResistor(lead_node[anode], lead_node[inode], aresistance);
}
public override void stamp(Circuit sim)
{
// Capacitor companion model using trapezoidal approximation
// (Norton equivalent) consists of a current source in
// parallel with a resistor. Trapezoidal is more accurate
// than backward euler but can cause oscillatory behavior
// if RC is small relative to the timestep.
if (isTrapezoidal)
{
compResistance = sim.timeStep / (2 * capacitance);
}
else
{
compResistance = sim.timeStep / capacitance;
}
sim.stampResistor(lead_node[0], lead_node[1], compResistance);
sim.stampRightSide(lead_node[0]);
sim.stampRightSide(lead_node[1]);
}
public void stamp(Circuit sim, double deltaTime, int n0, int n1)
{
// inductor companion model using trapezoidal or backward euler
// approximations (Norton equivalent) consists of a current
// source in parallel with a resistor. Trapezoidal is more
// accurate than backward euler but can cause oscillatory behavior.
// The oscillation is a real problem in circuits with switches.
nodes[0] = n0;
nodes[1] = n1;
if (isTrapezoidal)
{
compResistance = 2 * inductance / deltaTime;
}
else
{
compResistance = inductance / deltaTime; // backward euler
}
sim.stampResistor(nodes[0], nodes[1], compResistance);
sim.stampRightSide(nodes[0]);
sim.stampRightSide(nodes[1]);
}
/*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 stamp(Circuit sim)
{
sim.stampResistor(lead_node[0], lead_node[1], resistance);
}
public override void step(Circuit sim)
{
resistance = (state) ? onresistance : offresistance;
sim.stampResistor(lead_node[0], lead_node[1], resistance);
}
