public Complex GetCurrent(ComplexSimulationState state)
{
state.ThrowIfNull(nameof(state));
var geq = Capacitance * state.Laplace + Conductance;
var voltage = state.Solution[PosPrimeNode] - state.Solution[NegNode];
return voltage * geq;
}
/// <summary>
/// Unbind the behavior.
/// </summary>
public override void Unbind()
{
base.Unbind();
_state = null;
CCollectorCollectorPrimePtr = null;
CBaseBasePrimePtr = null;
CEmitterEmitterPrimePtr = null;
CCollectorPrimeCollectorPtr = null;
CCollectorPrimeBasePrimePtr = null;
CCollectorPrimeEmitterPrimePtr = null;
CBasePrimeBasePtr = null;
CBasePrimeCollectorPrimePtr = null;
CBasePrimeEmitterPrimePtr = null;
CEmitterPrimeEmitterPtr = null;
CEmitterPrimeCollectorPrimePtr = null;
CEmitterPrimeBasePrimePtr = null;
CCollectorCollectorPtr = null;
CBaseBasePtr = null;
CEmitterEmitterPtr = null;
CCollectorPrimeCollectorPrimePtr = null;
CBasePrimeBasePrimePtr = null;
CEmitterPrimeEmitterPrimePtr = null;
CSubstrateSubstratePtr = null;
CCollectorPrimeSubstratePtr = null;
CSubstrateCollectorPrimePtr = null;
CBaseCollectorPrimePtr = null;
CCollectorPrimeBasePtr = null;
}
public Complex GetCurrent(ComplexSimulationState state)
{
state.ThrowIfNull(nameof(state));
var conductance = state.Laplace * Capacitance;
return((state.Solution[PosNode] - state.Solution[NegNode]) * conductance);
}
/// <summary>
/// Bind the behavior.
/// </summary>
/// <param name="simulation"></param>
/// <param name="context"></param>
public override void Bind(Simulation simulation, BindingContext context)
{
base.Bind(simulation, context);
_state = ((FrequencySimulation)simulation).ComplexState;
var solver = _state.Solver;
CDrainDrainPtr = solver.GetMatrixElement(DrainNode, DrainNode);
CGateGatePtr = solver.GetMatrixElement(GateNode, GateNode);
CSourceSourcePtr = solver.GetMatrixElement(SourceNode, SourceNode);
CBulkBulkPtr = solver.GetMatrixElement(BulkNode, BulkNode);
CDrainPrimeDrainPrimePtr = solver.GetMatrixElement(DrainNodePrime, DrainNodePrime);
CSourcePrimeSourcePrimePtr = solver.GetMatrixElement(SourceNodePrime, SourceNodePrime);
CDrainDrainPrimePtr = solver.GetMatrixElement(DrainNode, DrainNodePrime);
CGateBulkPtr = solver.GetMatrixElement(GateNode, BulkNode);
CGateDrainPrimePtr = solver.GetMatrixElement(GateNode, DrainNodePrime);
CGateSourcePrimePtr = solver.GetMatrixElement(GateNode, SourceNodePrime);
CSourceSourcePrimePtr = solver.GetMatrixElement(SourceNode, SourceNodePrime);
CBulkDrainPrimePtr = solver.GetMatrixElement(BulkNode, DrainNodePrime);
CBulkSourcePrimePtr = solver.GetMatrixElement(BulkNode, SourceNodePrime);
CDrainPrimeSourcePrimePtr = solver.GetMatrixElement(DrainNodePrime, SourceNodePrime);
CDrainPrimeDrainPtr = solver.GetMatrixElement(DrainNodePrime, DrainNode);
CBulkGatePtr = solver.GetMatrixElement(BulkNode, GateNode);
CDrainPrimeGatePtr = solver.GetMatrixElement(DrainNodePrime, GateNode);
CSourcePrimeGatePtr = solver.GetMatrixElement(SourceNodePrime, GateNode);
CSourcePrimeSourcePtr = solver.GetMatrixElement(SourceNodePrime, SourceNode);
CDrainPrimeBulkPtr = solver.GetMatrixElement(DrainNodePrime, BulkNode);
CSourcePrimeBulkPtr = solver.GetMatrixElement(SourceNodePrime, BulkNode);
CSourcePrimeDrainPrimePtr = solver.GetMatrixElement(SourceNodePrime, DrainNodePrime);
}
/// <summary>
/// Unbind the behavior.
/// </summary>
public override void Unbind()
{
base.Unbind();
_state = null;
CDrainDrainPtr = null;
CGateGatePtr = null;
CSourceSourcePtr = null;
CBulkBulkPtr = null;
CDrainPrimeDrainPrimePtr = null;
CSourcePrimeSourcePrimePtr = null;
CDrainDrainPrimePtr = null;
CGateBulkPtr = null;
CGateDrainPrimePtr = null;
CGateSourcePrimePtr = null;
CSourceSourcePrimePtr = null;
CBulkDrainPrimePtr = null;
CBulkSourcePrimePtr = null;
CDrainPrimeSourcePrimePtr = null;
CDrainPrimeDrainPtr = null;
CBulkGatePtr = null;
CDrainPrimeGatePtr = null;
CSourcePrimeGatePtr = null;
CSourcePrimeSourcePtr = null;
CDrainPrimeBulkPtr = null;
CSourcePrimeBulkPtr = null;
CSourcePrimeDrainPrimePtr = null;
}
/// <summary>
/// Bind the behavior.
/// </summary>
/// <param name="simulation">The simulation.</param>
/// <param name="context">The context.</param>
public override void Bind(Simulation simulation, BindingContext context)
{
base.Bind(simulation, context);
_state = ((FrequencySimulation)simulation).ComplexState;
var solver = _state.Solver;
CCollectorCollectorPrimePtr = solver.GetMatrixElement(CollectorNode, CollectorPrimeNode);
CBaseBasePrimePtr = solver.GetMatrixElement(BaseNode, BasePrimeNode);
CEmitterEmitterPrimePtr = solver.GetMatrixElement(EmitterNode, EmitterPrimeNode);
CCollectorPrimeCollectorPtr = solver.GetMatrixElement(CollectorPrimeNode, CollectorNode);
CCollectorPrimeBasePrimePtr = solver.GetMatrixElement(CollectorPrimeNode, BasePrimeNode);
CCollectorPrimeEmitterPrimePtr = solver.GetMatrixElement(CollectorPrimeNode, EmitterPrimeNode);
CBasePrimeBasePtr = solver.GetMatrixElement(BasePrimeNode, BaseNode);
CBasePrimeCollectorPrimePtr = solver.GetMatrixElement(BasePrimeNode, CollectorPrimeNode);
CBasePrimeEmitterPrimePtr = solver.GetMatrixElement(BasePrimeNode, EmitterPrimeNode);
CEmitterPrimeEmitterPtr = solver.GetMatrixElement(EmitterPrimeNode, EmitterNode);
CEmitterPrimeCollectorPrimePtr = solver.GetMatrixElement(EmitterPrimeNode, CollectorPrimeNode);
CEmitterPrimeBasePrimePtr = solver.GetMatrixElement(EmitterPrimeNode, BasePrimeNode);
CCollectorCollectorPtr = solver.GetMatrixElement(CollectorNode, CollectorNode);
CBaseBasePtr = solver.GetMatrixElement(BaseNode, BaseNode);
CEmitterEmitterPtr = solver.GetMatrixElement(EmitterNode, EmitterNode);
CCollectorPrimeCollectorPrimePtr = solver.GetMatrixElement(CollectorPrimeNode, CollectorPrimeNode);
CBasePrimeBasePrimePtr = solver.GetMatrixElement(BasePrimeNode, BasePrimeNode);
CEmitterPrimeEmitterPrimePtr = solver.GetMatrixElement(EmitterPrimeNode, EmitterPrimeNode);
CSubstrateSubstratePtr = solver.GetMatrixElement(SubstrateNode, SubstrateNode);
CCollectorPrimeSubstratePtr = solver.GetMatrixElement(CollectorPrimeNode, SubstrateNode);
CSubstrateCollectorPrimePtr = solver.GetMatrixElement(SubstrateNode, CollectorPrimeNode);
CBaseCollectorPrimePtr = solver.GetMatrixElement(BaseNode, CollectorPrimeNode);
CCollectorPrimeBasePtr = solver.GetMatrixElement(CollectorPrimeNode, BaseNode);
}
public Complex GetPower(ComplexSimulationState state)
{
state.ThrowIfNull(nameof(state));
var v = state.Solution[PosNode] - state.Solution[NegNode];
return(-v *Complex.Conjugate(FrequencyParameters.Phasor));
}
/// <summary>
/// Unbind the behavior.
/// </summary>
public override void Unbind()
{
base.Unbind();
_state = null;
CPosControlBranchPtr = null;
CNegControlBranchPtr = null;
}
/// <summary>
/// Bind the behavior.
/// </summary>
/// <param name="simulation">The simulation.</param>
/// <param name="context">The context.</param>
public override void Bind(Simulation simulation, BindingContext context)
{
base.Bind(simulation, context);
_state = ((FrequencySimulation)simulation).ComplexState;
var solver = _state.Solver.ThrowIfNull("solver");
CPos1Pos1Ptr = solver.GetMatrixElement(Pos1, Pos1);
CPos1Int1Ptr = solver.GetMatrixElement(Pos1, Internal1);
CNeg1Ibr1Ptr = solver.GetMatrixElement(Neg1, BranchEq1);
CPos2Pos2Ptr = solver.GetMatrixElement(Pos2, Pos2);
CNeg2Ibr2Ptr = solver.GetMatrixElement(Neg2, BranchEq2);
CInt1Pos1Ptr = solver.GetMatrixElement(Internal1, Pos1);
CInt1Int1Ptr = solver.GetMatrixElement(Internal1, Internal1);
CInt1Ibr1Ptr = solver.GetMatrixElement(Internal1, BranchEq1);
CInt2Int2Ptr = solver.GetMatrixElement(Internal2, Internal2);
CInt2Ibr2Ptr = solver.GetMatrixElement(Internal2, BranchEq2);
CIbr1Neg1Ptr = solver.GetMatrixElement(BranchEq1, Neg1);
CIbr1Pos2Ptr = solver.GetMatrixElement(BranchEq1, Pos2);
CIbr1Neg2Ptr = solver.GetMatrixElement(BranchEq1, Neg2);
CIbr1Int1Ptr = solver.GetMatrixElement(BranchEq1, Internal1);
CIbr1Ibr2Ptr = solver.GetMatrixElement(BranchEq1, BranchEq2);
CIbr2Pos1Ptr = solver.GetMatrixElement(BranchEq2, Pos1);
CIbr2Neg1Ptr = solver.GetMatrixElement(BranchEq2, Neg1);
CIbr2Neg2Ptr = solver.GetMatrixElement(BranchEq2, Neg2);
CIbr2Int2Ptr = solver.GetMatrixElement(BranchEq2, Internal2);
CIbr2Ibr1Ptr = solver.GetMatrixElement(BranchEq2, BranchEq1);
CPos2Int2Ptr = solver.GetMatrixElement(Pos2, Internal2);
CInt2Pos2Ptr = solver.GetMatrixElement(Internal2, Pos2);
}
public Complex GetPower(ComplexSimulationState state)
{
state.ThrowIfNull(nameof(state));
var voltage = state.Solution[PosNode] - state.Solution[NegNode];
return(voltage * Complex.Conjugate(voltage) * Conductance);
}
/// <summary>
/// Setup behavior
/// </summary>
/// <param name="context">Provider</param>
public override void Bind(Simulation simulation, BindingContext context)
{
base.Bind(simulation, context);
// Get parameter sets
_mbp = context.GetParameterSet <ModelBaseParameters>("model");
_bp = context.GetParameterSet <BaseParameters>();
// Get behaviors
_load = context.GetBehavior <BiasingBehavior>();
_temp = context.GetBehavior <TemperatureBehavior>();
if (context is ComponentBindingContext cc)
{
_drainNode = cc.Pins[0];
_gateNode = cc.Pins[1];
_sourceNode = cc.Pins[2];
_bulkNode = cc.Pins[3];
}
_state = ((FrequencySimulation)simulation).ComplexState;
var solver = _state.Solver;
_drainNodePrime = _load.DrainNodePrime;
_sourceNodePrime = _load.SourceNodePrime;
_qNode = _load.QNode;
DdPtr = solver.GetMatrixElement(_drainNode, _drainNode);
GgPtr = solver.GetMatrixElement(_gateNode, _gateNode);
SsPtr = solver.GetMatrixElement(_sourceNode, _sourceNode);
BbPtr = solver.GetMatrixElement(_bulkNode, _bulkNode);
DPdpPtr = solver.GetMatrixElement(_drainNodePrime, _drainNodePrime);
SPspPtr = solver.GetMatrixElement(_sourceNodePrime, _sourceNodePrime);
DdpPtr = solver.GetMatrixElement(_drainNode, _drainNodePrime);
GbPtr = solver.GetMatrixElement(_gateNode, _bulkNode);
GdpPtr = solver.GetMatrixElement(_gateNode, _drainNodePrime);
GspPtr = solver.GetMatrixElement(_gateNode, _sourceNodePrime);
SspPtr = solver.GetMatrixElement(_sourceNode, _sourceNodePrime);
BdpPtr = solver.GetMatrixElement(_bulkNode, _drainNodePrime);
BspPtr = solver.GetMatrixElement(_bulkNode, _sourceNodePrime);
DPspPtr = solver.GetMatrixElement(_drainNodePrime, _sourceNodePrime);
DPdPtr = solver.GetMatrixElement(_drainNodePrime, _drainNode);
BgPtr = solver.GetMatrixElement(_bulkNode, _gateNode);
DPgPtr = solver.GetMatrixElement(_drainNodePrime, _gateNode);
SPgPtr = solver.GetMatrixElement(_sourceNodePrime, _gateNode);
SPsPtr = solver.GetMatrixElement(_sourceNodePrime, _sourceNode);
DPbPtr = solver.GetMatrixElement(_drainNodePrime, _bulkNode);
SPbPtr = solver.GetMatrixElement(_sourceNodePrime, _bulkNode);
SPdpPtr = solver.GetMatrixElement(_sourceNodePrime, _drainNodePrime);
QqPtr = solver.GetMatrixElement(_qNode, _qNode);
QdpPtr = solver.GetMatrixElement(_qNode, _drainNodePrime);
QspPtr = solver.GetMatrixElement(_qNode, _sourceNodePrime);
QgPtr = solver.GetMatrixElement(_qNode, _gateNode);
QbPtr = solver.GetMatrixElement(_qNode, _bulkNode);
DPqPtr = solver.GetMatrixElement(_drainNodePrime, _qNode);
SPqPtr = solver.GetMatrixElement(_sourceNodePrime, _qNode);
GqPtr = solver.GetMatrixElement(_gateNode, _qNode);
BqPtr = solver.GetMatrixElement(_bulkNode, _qNode);
}
public Complex GetDiodeVoltage(ComplexSimulationState state)
{
if (state == null)
{
throw new ArgumentNullException(nameof(state));
}
return(state.Solution[_posPrimeNode] - state.Solution[_negNode]);
}
public Complex GetPower(ComplexSimulationState state)
{
state.ThrowIfNull(nameof(state));
var geq = Capacitance * state.Laplace + Conductance;
var current = (state.Solution[PosPrimeNode] - state.Solution[NegNode]) * geq;
var voltage = state.Solution[PosNode] - state.Solution[NegNode];
return voltage * -Complex.Conjugate(current);
}
public Complex GetVoltage(ComplexSimulationState state)
{
if (state == null)
{
throw new ArgumentNullException(nameof(state));
}
return(state.Solution[PosNode] - state.Solution[NegNode]);
}
public Complex GetCurrent(ComplexSimulationState state)
{
if (state == null)
{
throw new ArgumentNullException(nameof(state));
}
return(state.Solution[_branchEq]);
}
public Complex GetPower(ComplexSimulationState state)
{
state.ThrowIfNull(nameof(state));
var v = state.Solution[PosNode] - state.Solution[NegNode];
var i = (state.Solution[ContPosNode] - state.Solution[ContNegNode]) * BaseParameters.Coefficient.Value;
return(-v *Complex.Conjugate(i));
}
/// <summary>
/// Unsetup the behavior.
/// </summary>
public override void Unbind()
{
BiasingBehavior = null;
State = null;
_fillMatrix = null;
_contributions = null;
_initializeMethod = null;
}
/// <summary>
/// Unbind the behavior.
/// </summary>
public override void Unbind()
{
base.Unbind();
_state = null;
CPosPosPtr = null;
CPosNegPtr = null;
CNegPosPtr = null;
CNegNegPtr = null;
}
public Complex GetCurrent(ComplexSimulationState state)
{
if (state == null)
{
throw new ArgumentNullException(nameof(state));
}
return((state.Solution[_contPosourceNode] - state.Solution[_contNegateNode]) * _bp.Coefficient.Value);
}
public Complex GetCurrent(ComplexSimulationState state)
{
if (state == null)
{
throw new ArgumentNullException(nameof(state));
}
return((state.Solution[ContPosNode] - state.Solution[ContNegNode]) * BaseParameters.Coefficient.Value);
}
public Complex GetPower(ComplexSimulationState state)
{
state.ThrowIfNull(nameof(state));
var v = state.Solution[PosNode] - state.Solution[NegNode];
var i = state.Solution[BranchEq];
return(-v *Complex.Conjugate(i));
}
public Complex GetCurrent(ComplexSimulationState state)
{
if (state == null)
{
throw new ArgumentNullException(nameof(state));
}
return(state.Solution[_contBranch] * _bp.Coefficient.Value);
}
/// <summary>
/// Unbind the behavior.
/// </summary>
public override void Unbind()
{
base.Unbind();
_state = null;
CPosBranchPtr = null;
CNegBranchPtr = null;
CBranchPosPtr = null;
CBranchNegPtr = null;
CBranchControlBranchPtr = null;
}
public Complex GetPower(ComplexSimulationState state)
{
if (state == null)
{
throw new ArgumentNullException(nameof(state));
}
var voltage = state.Solution[PosNode] - state.Solution[NegNode];
return(voltage * Complex.Conjugate(voltage) * Conductance);
}
/// <summary>
/// Bind the behavior.
/// </summary>
/// <param name="simulation">The simulation.</param>
/// <param name="context">The context.</param>
public override void Bind(Simulation simulation, BindingContext context)
{
base.Bind(simulation, context);
_state = ((FrequencySimulation)simulation).ComplexState;
var solver = _state.Solver;
CPosControlBranchPtr = solver.GetMatrixElement(PosNode, ControlBranchEq);
CNegControlBranchPtr = solver.GetMatrixElement(NegNode, ControlBranchEq);
}
public Complex GetCurrent(ComplexSimulationState state)
{
if (state == null)
{
throw new ArgumentNullException(nameof(state));
}
var conductance = state.Laplace * Capacitance;
return((state.Solution[PosNode] - state.Solution[NegNode]) * conductance);
}
public Complex GetPower(ComplexSimulationState state)
{
if (state == null)
{
throw new ArgumentNullException(nameof(state));
}
var v = state.Solution[PosNode] - state.Solution[NegNode];
return(-v *Complex.Conjugate(FrequencyParameters.Phasor));
}
public Complex GetPower(ComplexSimulationState state)
{
if (state == null)
{
throw new ArgumentNullException(nameof(state));
}
var v = state.Solution[_posNode] - state.Solution[_negNode];
return(-v *Complex.Conjugate(_ac));
}
public Complex GetCurrent(ComplexSimulationState state)
{
if (state == null)
{
throw new ArgumentNullException(nameof(state));
}
var geq = Capacitance * state.Laplace + Conductance;
var voltage = state.Solution[PosPrimeNode] - state.Solution[NegNode];
return(voltage * geq);
}
public Complex GetPower(ComplexSimulationState state)
{
if (state == null)
{
throw new ArgumentNullException(nameof(state));
}
var conductance = state.Laplace * _bp.Capacitance.Value;
var voltage = state.Solution[_posNode] - state.Solution[_negNode];
return(voltage * Complex.Conjugate(voltage * conductance));
}
