/// <summary>Performs necessary initialization of the device, like mapping to the equation system.</summary>
/// <param name="adapter">The equation system builder.</param>
/// <param name="context">Context of current simulation.</param>
public override void Initialize(IEquationSystemAdapter adapter, ISimulationContext context)
{
stamper.Register(adapter, Anode, Cathode);
voltage.Register(adapter, Anode, Cathode);
firstDcPoint = true;
IntegrationMethod = context.SimulationParameters.IntegrationMethodFactory.CreateInstance();
}
/// <inheritdoc/>
public IWaveform Create(IBindingContext context)
{
IIntegrationMethod method = null;
context?.TryGetState <IIntegrationMethod>(out method);
return(new Instance(Points, method));
}
/// <inheritdoc/>
public IWaveform Create(IBindingContext context)
{
IIntegrationMethod method = null;
TimeParameters tp = null;
context?.TryGetState(out method);
context?.TryGetSimulationParameterSet(out tp);
double step = 1.0;
if (!RiseTime.Given || !FallTime.Given)
{
if (tp is SpiceMethod sm)
{
step = sm.InitialStep;
}
else if (tp != null)
{
step = tp.StopTime / 50.0;
}
}
return(new Instance(method,
InitialValue,
PulsedValue,
Delay,
RiseTime.Given ? RiseTime.Value : step,
FallTime.Given ? FallTime.Value : step,
PulseWidth,
Period));
}
/// <summary>
/// Initializes a new instance of the <see cref="Time"/> class.
/// </summary>
/// <param name="context">The binding context.</param>
public Time(IBindingContext context)
: base(context)
{
_bp = context.GetParameterSet <Parameters>();
// Create derivatives for the numerator and denominator
_state = context.GetState <ITimeSimulationState>();
_method = context.GetState <IIntegrationMethod>();
if (_bp.Numerator.Length > 1)
{
_dNumerator = new IDerivative[_bp.Numerator.Length - 1];
for (int i = 0; i < _dNumerator.Length; i++)
{
_dNumerator[i] = _method.CreateDerivative();
}
}
else
{
_dNumerator = null;
}
if (_bp.Denominator.Length > 1)
{
_dDenominator = new IDerivative[_bp.Denominator.Length - 1];
for (int i = 0; i < _dDenominator.Length; i++)
{
_dDenominator[i] = _method.CreateDerivative();
}
}
else
{
_dDenominator = null;
}
}
/// <summary>Performs necessary initialization of the device, like mapping to the equation system.</summary>
/// <param name="adapter">The equation system builder.</param>
/// <param name="context">Context of current simulation.</param>
public override void Initialize(IEquationSystemAdapter adapter, ISimulationContext context)
{
stamper.Register(adapter, bprimeNode, cprimeNode, eprimeNode);
voltageBc.Register(adapter, bprimeNode, cprimeNode);
voltageBe.Register(adapter, bprimeNode, eprimeNode);
voltageCs.Register(adapter, cprimeNode, Substrate);
capacbe.Register(adapter, bprimeNode, eprimeNode);
capacbc.Register(adapter, bprimeNode, cprimeNode);
capaccs.Register(adapter, cprimeNode, Substrate);
chargebe = context.SimulationParameters.IntegrationMethodFactory.CreateInstance();
chargebc = context.SimulationParameters.IntegrationMethodFactory.CreateInstance();
chargecs = context.SimulationParameters.IntegrationMethodFactory.CreateInstance();
gb.Register(adapter, bprimeNode, Base);
gc.Register(adapter, cprimeNode, Collector);
ge.Register(adapter, eprimeNode, Emitter);
vT = PhysicalConstants.Boltzmann *
PhysicalConstants.CelsiusToKelvin(Parameters.NominalTemperature) /
PhysicalConstants.DevicearyCharge;
VoltageBaseEmitter = DeviceHelpers.PnCriticalVoltage(Parameters.SaturationCurrent, vT);
}
/// <summary>
/// Initializes a new instance of the <see cref="Instance"/> class.
/// </summary>
/// <param name="method">The integration method.</param>
/// <param name="vo">The offset.</param>
/// <param name="va">The amplitude.</param>
/// <param name="frequency">The frequency.</param>
/// <param name="td">The delay.</param>
/// <param name="theta">The theta.</param>
/// <param name="phase">The phase.</param>
public Instance(IIntegrationMethod method, double vo, double va, double frequency, double td, double theta, double phase)
{
_method = method;
_vo = vo;
_va = va;
_freq = frequency.GreaterThanOrEquals(nameof(frequency), 0) * 2.0 * Math.PI;
_td = td;
_theta = theta;
_phase = phase * Math.PI / 180;
Value = _vo;
}
public DerivativeTesterBehavior(IBindingContext context, Func <double, double> reference, double initial, double relTol, double absTol)
: base(context)
{
_biasing = context.GetState <IBiasingSimulationState>();
_method = context.GetState <IIntegrationMethod>();
_time = context.GetState <ITimeSimulationState>();
_derivative = _method.CreateDerivative();
_reference = reference;
_initial = initial;
_relTol = relTol;
_absTol = absTol;
}
/// <inheritdoc/>
public IWaveform Create(IBindingContext context)
{
IIntegrationMethod method = null;
TimeParameters tp = null;
context?.TryGetState <IIntegrationMethod>(out method);
context?.TryGetSimulationParameterSet <TimeParameters>(out tp);
return(new Instance(method,
Offset,
Amplitude,
Frequency.Given ? Frequency.Value : 1.0 / (tp?.StopTime ?? 1.0),
Delay,
Theta,
Phase));
}
/// <inheritdoc/>
public IWaveform Create(IBindingContext context)
{
IIntegrationMethod method = null;
TimeParameters tp = null;
context?.TryGetState(out method);
context?.TryGetSimulationParameterSet(out tp);
return(new Instance(method,
Amplitude,
Offset,
ModulationFrequency,
CarrierFrequency.Given ? CarrierFrequency.Value : 1.0 / (tp?.StopTime ?? 1.0),
SignalDelay,
CarrierPhase,
SignalPhase));
}
/// <summary>
/// Initializes a new instance of the <see cref="Truncating"/> class.
/// </summary>
/// <param name="context">The sampler binding context.</param>
public Truncating(SamplerBindingContext context)
: base(context)
{
_parameters = context.GetParameterSet <Parameters>();
_method = context.GetState <IIntegrationMethod>();
_points = _parameters.Points.GetEnumerator();
_continue = _points.MoveNext();
// Register to the export event
context.RegisterToExportEvent(OnExportSimulationData);
// Find the first timepoint that is eligible for targeting
while (_continue && _points.Current < -_parameters.MinDelta)
{
_continue = _points.MoveNext();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Instance"/> class.
/// </summary>
/// <param name="method">The integration method.</param>
/// <param name="v1">The initial/low value.</param>
/// <param name="v2">The pulsed/high value.</param>
/// <param name="td">The delay.</param>
/// <param name="tr">The rise time.</param>
/// <param name="tf">The fall time.</param>
/// <param name="pw">The pulse width.</param>
/// <param name="per">The period.</param>
public Instance(IIntegrationMethod method,
double v1, double v2, double td, double tr, double tf, double pw, double per)
{
_method = method;
// Cache parameter values
_v1 = v1;
_v2 = v2;
_td = td.GreaterThanOrEquals(nameof(td), 0);
_tr = tr.GreaterThanOrEquals(nameof(tr), 0);
_tf = tf.GreaterThanOrEquals(nameof(tf), 0);
_pw = pw.GreaterThanOrEquals(nameof(pw), 0);
_per = per.GreaterThanOrEquals(nameof(per), _tr + _pw + _tf);
// Initialize the value
At(0.0);
}
/// <summary>
/// Initializes a new instance of the <see cref="Time"/> class.
/// </summary>
/// <param name="context">The context.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="context"/> is <c>null</c>.</exception>
public Time(BehavioralBindingContext context)
: base(context)
{
var bp = context.GetParameterSet <Parameters>();
var state = context.GetState <IBiasingSimulationState>();
_method = context.GetState <IIntegrationMethod>();
_time = context.GetState <ITimeSimulationState>();
var derivatives = new List <Func <double> >(Derivatives.Count);
var derivativeVariables = new List <IVariable <double> >(Derivatives.Count);
var builder = new RealFunctionBuilder();
builder.VariableFound += (sender, args) =>
{
if (args.Variable == null && DerivativeVariables.TryGetValue(args.Node, out var variable))
{
args.Variable = variable;
}
};
bp.RegisterBuilder(context, builder);
var matLocs = new List <MatrixLocation>(Derivatives.Count * 2);
var rhsLocs = Variables.GetRhsIndices(state.Map);
foreach (var pair in Derivatives)
{
var variable = DerivativeVariables[pair.Key];
if (state.Map.Contains(variable))
{
derivatives.Add(builder.Build(pair.Value));
derivativeVariables.Add(variable);
matLocs.Add(new MatrixLocation(rhsLocs[0], state.Map[variable]));
matLocs.Add(new MatrixLocation(rhsLocs[1], state.Map[variable]));
}
}
_value = builder.Build(Function);
_derivatives = derivatives.ToArray();
_values = new double[_derivatives.Length * 2 + 2];
_derivativeVariables = derivativeVariables.ToArray();
// Get the matrix elements
_elements = new ElementSet <double>(state.Solver, matLocs.ToArray(), rhsLocs);
// Create the derivative
_qcap = _method.CreateDerivative();
}
/// <summary>
/// Initializes a new instance of the <see cref="Instance"/> class.
/// </summary>
/// <param name="method">The integration method.</param>
/// <param name="offset">The offset.</param>
/// <param name="amplitude">The amplitude.</param>
/// <param name="carrierFrequency">The carrier frequency.</param>
/// <param name="modulationIndex">The modulation index.</param>
/// <param name="signalFrequency">The signal frequency.</param>
/// <param name="carrierPhase">The carrier phase.</param>
/// <param name="signalPhase">The signal phase.</param>
public Instance(IIntegrationMethod method,
double offset, double amplitude,
double carrierFrequency, double modulationIndex, double signalFrequency,
double carrierPhase, double signalPhase)
{
_method = method;
_vo = offset;
_va = amplitude;
_fc = carrierFrequency * Math.PI * 2.0;
_mdi = modulationIndex;
_fs = signalFrequency * Math.PI * 2.0;
_phasec = carrierPhase * Math.PI / 180.0;
_phases = signalPhase * Math.PI / 180.0;
// Initialize the value
At(0.0);
}
/// <summary>
/// Initializes a new instance of the <see cref="Instance"/> class.
/// </summary>
/// <param name="points">The points.</param>
/// <param name="method">The integration method.</param>
/// <exception cref="ArgumentException">Thrown if no points are specified, or if the time values are not monotonically increasing.</exception>
public Instance(IEnumerable <Point> points, IIntegrationMethod method)
{
_method = method;
_points = points.ThrowIfNull(nameof(points)).ToArray();
if (_points.Length == 0)
{
throw new ArgumentException(Properties.Resources.Waveforms_Pwl_Empty);
}
// Check monotonically increasing timepoints
for (var i = 1; i < _points.Length; i++)
{
if (_points[i - 1].Time >= _points[i].Time)
{
throw new ArgumentException(Properties.Resources.Waveforms_Pwl_NoIncreasingTimeValues);
}
}
_index = 0;
Probe();
}
private void integrateButton_Click(object sender, RoutedEventArgs e)
{
try
{
var function = ExpressionParser.GetFunction(integrationFunctionInput.Text);
double a = double.Parse(integrationInputA.Text);
double b = double.Parse(integrationInputB.Text);
if (b <= a)
{
throw new ArgumentException($"Incorrect interval: [{a}; {b}]\nb must be greater then a");
}
int n = (int)integrNodesSlider.Value;
IIntegrationMethod integrationMethod = null;
if (integrationMethodSelect.SelectedIndex == 0)
{
integrationMethod = new RectangleMethod();
}
else if (integrationMethodSelect.SelectedIndex == 1)
{
integrationMethod = new TrapezoidMethod();
}
else if (integrationMethodSelect.SelectedIndex == 2)
{
integrationMethod = new SimpsonsMethod();
}
double result = integrationMethod.Calculate(function, a, b, n);
integrationResultText.Text = $"{result:f15}";
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error");
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Accept"/> class.
/// </summary>
/// <param name="context">The context.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="context"/> is <c>null</c>.</exception>
public Accept(IComponentBindingContext context)
: base(context)
{
_method = context.GetState <IIntegrationMethod>();
}
/// <inheritdoc />
protected override void CreateStates()
{
base.CreateStates();
_method = TimeParameters.Create(GetState <IBiasingSimulationState>());
}
/// <inheritdoc/>
public IWaveform Create(IIntegrationMethod method)
{
return(new Instance(method,
InitialValue, PulsedValue, Delay, RiseTime, FallTime, PulseWidth, Period));
}
/// <inheritdoc/>
public IWaveform Create(IIntegrationMethod method)
{
return(new Instance(Points, method));
}
/// <summary>
/// Initializes a new instance of the <see cref="Accept"/> class.
/// </summary>
/// <param name="context">The context.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="context"/> is <c>null</c>.</exception>
public Accept(IComponentBindingContext context)
: base(context)
{
context.ThrowIfNull(nameof(context));
_method = context.GetState <IIntegrationMethod>();
}
