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)); }