public override SpiceSharp.Components.Model Generate(string id, string type, ParameterCollection parameters, ICircuitContext context)
{
var model = new DiodeModel(id);
SetParameters(context, model, parameters);
return(model);
}
public override SpiceSharp.Components.Component Generate(string name, string originalName, string type, ParameterCollection parameters, ICircuitContext context)
{
var losslessLine = new LosslessTransmissionLine(name);
context.CreateNodes(losslessLine, parameters);
parameters = parameters.Skip(4);
foreach (Parameter parameter in parameters)
{
if (parameter is AssignmentParameter ap)
{
var paramName = ap.Name.ToLower();
if (paramName == "z0" || paramName == "zo")
{
context.SetParameter(losslessLine, "z0", ap.Value);
}
else if (paramName == "f")
{
context.SetParameter(losslessLine, "f", ap.Value);
}
else if (paramName == "td")
{
context.SetParameter(losslessLine, "td", ap.Value);
}
else if (paramName == "reltol")
{
context.SetParameter(losslessLine, "reltol", ap.Value);
}
else if (paramName == "abstol")
{
context.SetParameter(losslessLine, "abstol", ap.Value);
}
else
{
context.Result.Validation.Add(new ValidationEntry(ValidationEntrySource.Reader, ValidationEntryLevel.Warning, $"Invalid parameter: {parameter.Image}", parameter.LineInfo));
}
}
}
return(losslessLine);
}
private static void CreateRowInPrint(ref int rowIndex, Simulation simulation, ICircuitContext context, ExportDataEventArgs eventArgs, List <Export> exports, Print print)
{
Row row = new Row(rowIndex++);
double x = 0;
if (simulation is Transient)
{
x = eventArgs.Time;
}
if (simulation is AC)
{
x = eventArgs.Frequency;
}
if (simulation is DC dc)
{
if (dc.Sweeps.Count > 1)
{
// TODO: Add support for DC Sweeps > 1
context.Result.Validation.Add(new ValidationEntry(ValidationEntrySource.Reader, ValidationEntryLevel.Warning, ".PRINT doesn't support sweep count > 1"));
return;
}
x = eventArgs.SweepValue;
}
if (!(simulation is OP))
{
row.Columns.Add(x);
}
for (var i = 0; i < exports.Count; i++)
{
try
{
double val = exports[i].Extract();
row.Columns.Add(val);
}
catch (Exception)
{
row.Columns.Add(double.NaN);
}
}
print.Rows.Add(row);
}
public static void SetServiceName(this ICircuitContext context, string serviceName)
{
context.Set(KeyServiceName, serviceName);
}
public override SpiceSharp.Components.Model Generate(string id, string type, ParameterCollection parameters, ICircuitContext context)
{
SpiceSharp.Components.Model model = null;
switch (type.ToLower())
{
case "sw": model = new VoltageSwitchModel(id); break;
case "csw": model = new CurrentSwitchModel(id); break;
case "vswitch": model = new VSwitchModel(id); break;
case "iswitch": model = new ISwitchModel(id); break;
}
if (model != null)
{
SetParameters(context, model, parameters);
}
return(model);
}
/// <summary>
/// Reads <see cref="Control"/> statement and modifies the context
/// </summary>
/// <param name="statement">A statement to process</param>
/// <param name="context">A context to modify</param>
public override void Read(Control statement, ICircuitContext context)
{
foreach (var param in statement.Parameters)
{
if (param is Models.Netlist.Spice.Objects.Parameters.AssignmentParameter a)
{
string name = a.Name.ToLower();
string value = a.Value;
switch (name)
{
case "abstol":
context.Result.SimulationConfiguration.AbsoluteTolerance = context.Evaluator.EvaluateDouble(value); break;
case "reltol":
context.Result.SimulationConfiguration.RelTolerance = context.Evaluator.EvaluateDouble(value); break;
case "gmin":
context.Result.SimulationConfiguration.Gmin = context.Evaluator.EvaluateDouble(value); break;
case "itl1":
context.Result.SimulationConfiguration.DCMaxIterations = (int)context.Evaluator.EvaluateDouble(value); break;
case "itl2":
context.Result.SimulationConfiguration.SweepMaxIterations = (int)context.Evaluator.EvaluateDouble(value); break;
case "itl4":
context.Result.SimulationConfiguration.TranMaxIterations = (int)context.Evaluator.EvaluateDouble(value); break;
case "itl5":
// TODO: ????
break;
case "temp":
double temp = context.Evaluator.EvaluateDouble(value) + Constants.CelsiusKelvin;
context.Result.SimulationConfiguration.TemperaturesInKelvinsFromOptions = temp;
context.Result.SimulationConfiguration.TemperaturesInKelvins.Add(temp); break;
case "tnom":
context.Result.SimulationConfiguration.NominalTemperatureInKelvins = context.Evaluator.EvaluateDouble(value) + Constants.CelsiusKelvin; break;
case "method":
switch (value.ToLower())
{
case "trap":
case "trapezoidal":
context.Result.SimulationConfiguration.Method = new Trapezoidal();
break;
case "gear":
context.Result.SimulationConfiguration.Method = new Gear();
break;
case "euler":
context.Result.SimulationConfiguration.Method = new FixedEuler();
break;
}
break;
case "seed":
var seed = int.Parse(value);
context.Result.SimulationConfiguration.Seed = seed;
context.Evaluator.Seed = seed;
break;
case "distribution":
context.Evaluator.GetEvaluationContext().Randomizer.CurrentPdfName = value;
break;
case "cdfpoints":
var points = (int)context.Evaluator.EvaluateDouble(value);
if (points < 4)
{
context.Result.Validation.Add(new ValidationEntry(ValidationEntrySource.Reader, ValidationEntryLevel.Warning, "CDFPOINTS needs to be greater than 3", statement.LineInfo));
return;
}
context.Evaluator.GetEvaluationContext().Randomizer.CdfPoints = points;
break;
case "normallimit":
context.Evaluator.GetEvaluationContext().Randomizer.NormalLimit = context.Evaluator.EvaluateDouble(value);
break;
default:
context.Result.Validation.Add(new ValidationEntry(ValidationEntrySource.Reader, ValidationEntryLevel.Warning, $"Unsupported option: {name}", statement.LineInfo));
break;
}
}
if (param is Models.Netlist.Spice.Objects.Parameters.WordParameter w)
{
if (w.Image.ToLower() == "keepopinfo")
{
context.Result.SimulationConfiguration.KeepOpInfo = true;
}
if (w.Image.ToLower() == "dynamic-resistors")
{
context.Result.SimulationConfiguration.DynamicResistors = true;
}
}
}
}
public static void SetAppName(this ICircuitContext context, string appName)
{
context.Set(KeyAppName, appName);
}
public abstract IEntity Generate(string componentIdentifier, string originalName, string type, ParameterCollection parameters, ICircuitContext context);
public override Model Generate(string id, string type, SpiceSharpParser.Models.Netlist.Spice.Objects.ParameterCollection parameters, ICircuitContext context)
{
BipolarJunctionTransistorModel model = new BipolarJunctionTransistorModel(id);
if (type.ToLower() == "npn")
{
model.SetParameter("npn", true);
}
else if (type.ToLower() == "pnp")
{
model.SetParameter("pnp", true);
}
SetParameters(context, model, parameters);
return(new Model(id, model, model.Parameters));
}
public override SpiceSharp.Components.Model Generate(string id, string type, ParameterCollection parameters, ICircuitContext context)
{
BipolarJunctionTransistorModel model = new BipolarJunctionTransistorModel(id);
if (type.ToLower() == "npn")
{
model.SetParameter("npn", true);
}
else if (type.ToLower() == "pnp")
{
model.SetParameter("pnp", true);
}
SetParameters(context, model, parameters);
return(model);
}
public abstract SpiceSharp.Components.Model Generate(string id, string type, ParameterCollection parameters, ICircuitContext context);
/// <summary>
/// Reads <see cref="Control"/> statement and modifies the context.
/// </summary>
/// <param name="statement">A statement to process.</param>
/// <param name="context">A context to modify.</param>
public override void Read(Control statement, ICircuitContext context)
{
CreateSimulations(statement, context, CreateDCSimulation);
}
public EnableStochasticModelsSimulationDecorator(ICircuitContext context)
{
_context = context;
}
/// <summary>
/// Reads <see cref="Control"/> statement and modifies the context.
/// </summary>
/// <param name="statement">A statement to process.</param>
/// <param name="context">A context to modify.</param>
public override void Read(Control statement, ICircuitContext context)
{
Read(statement, context.Evaluator.GetEvaluationContext(), context.Result.Validation, true);
}
/// <summary> /// Generates a new waveform. /// </summary> /// <param name="parameters">Parameters for waveform.</param> /// <param name="context">A context.</param> /// <returns> /// A new waveform. /// </returns> public abstract Waveform Generate(ParameterCollection parameters, ICircuitContext context);
public SpiceSharp.Components.Component Generate(string componentIdentifier, string originalName, string type, ParameterCollection parameters, ICircuitContext context)
{
BipolarJunctionTransistor bjt = new BipolarJunctionTransistor(componentIdentifier);
// If the component is of the format QXXX NC NB NE MNAME off we will insert NE again before the model name
if (parameters.Count == 5 && parameters[4] is WordParameter w && w.Image == "off")
{
parameters.Insert(3, parameters[2]);
}
// If the component is of the format QXXX NC NB NE MNAME we will insert NE again before the model name
if (parameters.Count == 4)
{
parameters.Insert(3, parameters[2]);
}
context.CreateNodes(bjt, parameters);
if (parameters.Count < 5)
{
context.Result.Validation.Add(new ValidationEntry(ValidationEntrySource.Reader, ValidationEntryLevel.Warning, "Wrong parameters count for BJT", parameters.LineInfo));
return(null);
}
context.SimulationPreparations.ExecuteActionBeforeSetup((simulation) =>
{
context.ModelsRegistry.SetModel(
bjt,
simulation,
parameters.Get(4),
$"Could not find model {parameters.Get(4)} for BJT {originalName}",
(BipolarJunctionTransistorModel model) => bjt.Model = model.Name,
context.Result);
});
for (int i = 5; i < parameters.Count; i++)
{
var parameter = parameters[i];
if (parameter is SingleParameter s)
{
if (s is WordParameter)
{
switch (s.Image.ToLower())
{
case "on": bjt.SetParameter("off", false); break;
case "off": bjt.SetParameter("on", false); break;
default: throw new System.Exception();
}
}
else
{
// TODO: Fix this please it's broken ...
BaseParameters bp = bjt.ParameterSets.Get <BaseParameters>();
if (!bp.Area.Given)
{
bp.Area.Value = context.Evaluator.EvaluateDouble(s.Image);
}
if (!bp.Temperature.Given)
{
bp.Temperature.Value = context.Evaluator.EvaluateDouble(s.Image);
}
}
}
if (parameter is AssignmentParameter asg)
{
if (asg.Name.ToLower() == "ic")
{
context.SetParameter(bjt, "ic", asg.Value);
}
}
}
return(bjt);
}
protected void SetSweepSimulation(ICircuitContext context, List <KeyValuePair <Parameter, double> > parameterValues, BaseSimulation simulation)
{
ParameterUpdater.Update(simulation, context, parameterValues);
}
public SpiceSharp.Components.Component Generate(string componentIdentifier, string originalName, string type, ParameterCollection parameters, ICircuitContext context)
{
if (parameters.Count < 4)
{
throw new System.Exception("Model expected");
}
JFET jfet = new JFET(componentIdentifier);
context.CreateNodes(jfet, parameters);
context.SimulationPreparations.ExecuteActionBeforeSetup((simulation) =>
{
context.ModelsRegistry.SetModel(
jfet,
simulation,
parameters.Get(3),
$"Could not find model {parameters.Get(3)} for JFET {originalName}",
(JFETModel model) => jfet.Model = model.Name,
context.Result);
});
// Read the rest of the parameters
for (int i = 3; i < parameters.Count; i++)
{
if (parameters[i] is WordParameter w)
{
if (w.Image.ToLower() == "off")
{
jfet.SetParameter("off", true);
}
}
if (parameters[i] is AssignmentParameter asg)
{
if (asg.Name.ToLower() == "ic")
{
if (asg.Value.Length == 2)
{
context.SetParameter(jfet, "ic-vds", asg.Values[0]);
context.SetParameter(jfet, "ic-vgs", asg.Values[1]);
}
if (asg.Value.Length == 1)
{
context.SetParameter(jfet, "ic-vds", asg.Values[0]);
}
}
else if (asg.Name.ToLower() == "temp")
{
context.SetParameter(jfet, "temp", asg.Value);
}
else if (asg.Name.ToLower() == "area")
{
context.SetParameter(jfet, "area", asg.Value);
}
else
{
throw new System.Exception("Unknown parameter: " + asg.Name);
}
}
if (parameters[i] is ValueParameter || parameters[i] is ExpressionParameter)
{
context.SetParameter(jfet, "area", parameters[i].Image);
}
}
return(jfet);
}
public static T Get <T>(this ICircuitContext context, string name)
{
var result = context.Get(name);
return(result == null ? default(T) : (T)result);
}
public override IEntity Generate(string componentIdentifier, string originalName, string type, ParameterCollection parameters, ICircuitContext context)
{
switch (type.ToLower())
{
case "v": return(GenerateVoltageSource(componentIdentifier, parameters, context));
case "h": return(GenerateCurrentControlledVoltageSource(componentIdentifier, parameters, context));
case "e": return(GenerateVoltageControlledVoltageSource(componentIdentifier, parameters, context));
}
return(null);
}
public static string GetAppName(this ICircuitContext context)
{
return(context.Get <string>(KeyAppName));
}
protected void SetSourceParameters(
ParameterCollection parameters,
ICircuitContext context,
Component component)
{
var originalParameters = parameters;
parameters = parameters.Skip(VoltageSource.PinCount);
var acParameter = parameters.FirstOrDefault(p => p.Image.ToLower() == "ac");
if (acParameter != null)
{
int acParameterIndex = parameters.IndexOf(acParameter);
if (acParameterIndex != parameters.Count - 1)
{
var acParameterValue = parameters.Get(acParameterIndex + 1);
context.SetParameter(component, "acmag", acParameterValue);
if (acParameterIndex + 1 != parameters.Count - 1)
{
// Check first if next parameter is waveform
var acPhaseCandidate = parameters[acParameterIndex + 2].Image;
if (parameters[acParameterIndex + 2] is SingleParameter &&
!context.WaveformReader.Supports(acPhaseCandidate, context) &&
acPhaseCandidate.ToLower() != "dc")
{
var acPhaseParameterValue = parameters.Get(acParameterIndex + 2);
context.SetParameter(component, "acphase", acPhaseParameterValue);
parameters.RemoveAt(acParameterIndex + 2);
}
}
parameters.RemoveAt(acParameterIndex + 1);
}
parameters.RemoveAt(acParameterIndex);
}
// 2. Set DC
var dcParameter = parameters.FirstOrDefault(p => p.Image.ToLower() == "dc");
if (dcParameter != null)
{
int dcParameterIndex = parameters.IndexOf(dcParameter);
if (dcParameterIndex != parameters.Count - 1)
{
var dcParameterValue = parameters.Get(dcParameterIndex + 1);
context.SetParameter(component, "dc", dcParameterValue);
parameters.RemoveAt(dcParameterIndex + 1);
}
parameters.RemoveAt(dcParameterIndex);
}
else
{
if (parameters.Count > 0 &&
parameters[0] is SingleParameter sp &&
!context.WaveformReader.Supports(sp.Image, context) &&
parameters[0].Image.ToLower() != "value")
{
context.SetParameter(component, "dc", sp);
parameters.RemoveAt(0);
}
}
// 3. Set up waveform
if (parameters.Count > 0)
{
var firstParameter = parameters[0];
if (firstParameter is BracketParameter bp)
{
if (context.WaveformReader.Supports(bp.Name, context))
{
component.SetParameter("waveform", context.WaveformReader.Generate(bp.Name, bp.Parameters, context));
}
else
{
context.Result.Validation.Add(new ValidationEntry(ValidationEntrySource.Reader, ValidationEntryLevel.Warning, $"Unsupported waveform: {bp.Name}", bp.LineInfo));
}
}
else
{
if (firstParameter is WordParameter wp && wp.Image.ToLower() != "value")
{
if (context.WaveformReader.Supports(wp.Image, context))
{
component.SetParameter("waveform", context.WaveformReader.Generate(wp.Image, parameters.Skip(1), context));
}
else
{
context.Result.Validation.Add(new ValidationEntry(ValidationEntrySource.Reader, ValidationEntryLevel.Warning, $"Unsupported waveform: {wp}", wp.LineInfo));
}
}
}
if (firstParameter is AssignmentParameter ap && ap.Name.ToLower() == "value")
{
context.SetParameter(component, "dc", ap.Value);
}
if (parameters.Count >= 2 &&
parameters[0].Image.ToLower() == "value" &&
parameters[1] is SingleParameter)
{
context.SetParameter(component, "dc", parameters[1].Image);
}
}
context.CreateNodes(component, originalParameters);
}
public static string GetServiceName(this ICircuitContext context)
{
return(context.Get <string>(KeyServiceName));
}
/// <summary>
/// Generates a waveform from bracket parameter.
/// </summary>
/// <param name="type">Type.</param>
/// <param name="parameters">Parameters.</param>
/// <param name="context">A reading context.</param>
/// <returns>
/// An new instance of waveform.
/// </returns>
public IWaveformDescription Generate(string type, ParameterCollection parameters, ICircuitContext context)
{
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (!Mapper.TryGetValue(type, context.CaseSensitivity.IsFunctionNameCaseSensitive, out var reader))
{
context.Result.Validation.Add(
new ValidationEntry(
ValidationEntrySource.Reader,
ValidationEntryLevel.Warning,
$"Unsupported waveform '{type}'",
parameters.LineInfo));
return(null);
}
return(reader.Generate(parameters, context));
}
protected void SetIndependentSource(Entity @entity, BaseSimulation simulation, ICircuitContext context, KeyValuePair <SpiceSharpParser.Models.Netlist.Spice.Objects.Parameter, double> paramToSet)
{
if (@entity is CurrentSource || @entity is VoltageSource)
{
context
.SimulationPreparations
.SetParameter(@entity, simulation, "dc", paramToSet.Value, true, false);
}
}
public override IEntity Generate(string componentIdentifier, string originalName, string type, SpiceSharpParser.Models.Netlist.Spice.Objects.ParameterCollection parameters, ICircuitContext context)
{
// Errors
switch (parameters.Count)
{
case 0:
context.Result.Validation.Add(
new ValidationEntry(
ValidationEntrySource.Reader,
ValidationEntryLevel.Error,
$"Node expected for component {componentIdentifier}",
parameters.LineInfo));
return(null);
case 1:
case 2:
case 3:
context.Result.Validation.Add(
new ValidationEntry(
ValidationEntrySource.Reader,
ValidationEntryLevel.Error,
$"Node expected",
parameters.LineInfo));
return(null);
case 4:
context.Result.Validation.Add(
new ValidationEntry(
ValidationEntrySource.Reader,
ValidationEntryLevel.Error,
$"Model name expected",
parameters.LineInfo));
return(null);
}
// Get the model and generate a component for it
SpiceSharp.Components.Component mosfet = null;
var modelNameParameter = parameters.Get(4);
var model = context.ModelsRegistry.FindModel(modelNameParameter.Image);
if (model == null)
{
context.Result.Validation.Add(
new ValidationEntry(
ValidationEntrySource.Reader,
ValidationEntryLevel.Error,
$"Could not find model {modelNameParameter.Image} for mosfet {originalName}",
parameters.LineInfo));
return(null);
}
if (Mosfets.ContainsKey(model.GetType()))
{
var mosfetDetails = Mosfets[model.GetType()].Invoke(componentIdentifier);
mosfet = mosfetDetails.Mosfet;
context.SimulationPreparations.ExecuteActionBeforeSetup((simulation) =>
{
context.ModelsRegistry.SetModel(
mosfetDetails.Mosfet,
simulation,
modelNameParameter,
$"Could not find model {modelNameParameter.Image} for mosfet {componentIdentifier}",
mosfetDetails.SetModelAction,
context.Result);
});
}
else
{
context.Result.Validation.Add(
new ValidationEntry(
ValidationEntrySource.Reader,
ValidationEntryLevel.Error,
$"Invalid model {model.GetType()} for {componentIdentifier}",
parameters.LineInfo));
return(null);
}
// The rest is all just parameters
context.CreateNodes(mosfet, parameters);
SetParameters(context, mosfet, parameters.Skip(5), true);
return(mosfet);
}
private void RegisterParameter(ParameterCollection parameters, ICircuitContext context)
{
var variableParameter = parameters[0];
context.Evaluator.SetParameter(variableParameter.Image, 0);
}
public IEntity Generate(string componentIdentifier, string originalName, string type, ParameterCollection parameters, ICircuitContext context)
{
if (parameters.Count < 3)
{
throw new System.Exception("Model expected");
}
Diode diode = new Diode(componentIdentifier);
context.CreateNodes(diode, parameters);
context.SimulationPreparations.ExecuteActionBeforeSetup((simulation) =>
{
context.ModelsRegistry.SetModel(
diode,
simulation,
parameters.Get(2),
$"Could not find model {parameters.Get(2)} for diode {originalName}",
(Context.Models.Model model) => diode.Model = model.Name,
context.Result);
});
// Read the rest of the parameters
for (int i = 3; i < parameters.Count; i++)
{
if (parameters[i] is WordParameter w)
{
if (w.Image.ToLower() == "on")
{
diode.SetParameter("off", false);
}
else if (w.Image.ToLower() == "off")
{
diode.SetParameter("off", true);
}
else
{
throw new System.Exception("Expected on/off for diode");
}
}
if (parameters[i] is AssignmentParameter asg)
{
if (asg.Name.ToLower() == "ic")
{
context.SetParameter(diode, "ic", asg.Value);
}
}
if (parameters[i] is ValueParameter || parameters[i] is ExpressionParameter)
{
// TODO: Fix this please it's broken ...
var bp = diode.GetParameterSet <Parameters>();
if (bp.Area == 0.0)
{
bp.Area = context.Evaluator.EvaluateDouble(parameters.Get(i));
}
else
{
if (!bp.Temperature.Given)
{
bp.Temperature = context.Evaluator.EvaluateDouble(parameters.Get(i));
}
}
}
}
return(diode);
}
/// <summary>
/// Generates a new sinusoidal waveform.
/// </summary>
/// <param name="parameters">A parameter for waveform.</param>
/// <param name="context">A context.</param>
/// <returns>
/// A new waveform.
/// </returns>
public override IWaveformDescription Generate(ParameterCollection parameters, ICircuitContext context)
{
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (parameters.Count < 3 || parameters.Count > 6)
{
context.Result.Validation.Add(new ValidationEntry(ValidationEntrySource.Reader, ValidationEntryLevel.Warning, "Wrong parameters count for sine. There must be 3, 4, 5 or 6 parameters", parameters.LineInfo));
}
var sine = new Sine();
sine.Offset = context.Evaluator.EvaluateDouble(parameters.Get(0));
sine.Amplitude = context.Evaluator.EvaluateDouble(parameters.Get(1));
sine.Frequency = context.Evaluator.EvaluateDouble(parameters.Get(2));
if (parameters.Count >= 4)
{
sine.Delay = context.Evaluator.EvaluateDouble(parameters.Get(3));
}
if (parameters.Count >= 5)
{
sine.Theta = context.Evaluator.EvaluateDouble(parameters.Get(4));
}
if (parameters.Count == 6)
{
sine.Phase = context.Evaluator.EvaluateDouble(parameters.Get(5));
}
return(sine);
}
private Noise CreateNoiseSimulation(string name, Control statement, ICircuitContext context)
{
Noise noise = null;
// Check parameter count
switch (statement.Parameters.Count)
{
case 0:
context.Result.Validation.Add(new ValidationEntry(ValidationEntrySource.Reader, ValidationEntryLevel.Warning, "SpiceModel expected for .NOISE", statement.LineInfo));
return(null);
case 1:
context.Result.Validation.Add(new ValidationEntry(ValidationEntrySource.Reader, ValidationEntryLevel.Warning, "Source expected", statement.LineInfo));
return(null);
case 2:
context.Result.Validation.Add(new ValidationEntry(ValidationEntrySource.Reader, ValidationEntryLevel.Warning, "Step type expected", statement.LineInfo));
return(null);
case 3:
context.Result.Validation.Add(new ValidationEntry(ValidationEntrySource.Reader, ValidationEntryLevel.Warning, "Number of points expected", statement.LineInfo));
return(null);
case 4:
context.Result.Validation.Add(new ValidationEntry(ValidationEntrySource.Reader, ValidationEntryLevel.Warning, "Starting frequency expected", statement.LineInfo));
return(null);
case 5:
context.Result.Validation.Add(new ValidationEntry(ValidationEntrySource.Reader, ValidationEntryLevel.Warning, "Stopping frequency expected", statement.LineInfo));
return(null);
case 6: break;
case 7: break;
default:
context.Result.Validation.Add(new ValidationEntry(ValidationEntrySource.Reader, ValidationEntryLevel.Warning, "Too many parameters for .NOISE", statement.LineInfo));
return(null);
}
string type = statement.Parameters.Get(2).Image;
var numberSteps = context.Evaluator.EvaluateDouble(statement.Parameters.Get(3));
var start = context.Evaluator.EvaluateDouble(statement.Parameters.Get(4));
var stop = context.Evaluator.EvaluateDouble(statement.Parameters.Get(5));
Sweep <double> sweep;
switch (type)
{
case "lin": sweep = new LinearSweep(start, stop, (int)numberSteps); break;
case "oct": sweep = new OctaveSweep(start, stop, (int)numberSteps); break;
case "dec": sweep = new DecadeSweep(start, stop, (int)numberSteps); break;
default:
context.Result.Validation.Add(new ValidationEntry(ValidationEntrySource.Reader, ValidationEntryLevel.Warning, "LIN, DEC or OCT expected", statement.LineInfo));
return(null);
}
// The first parameters needs to specify the output voltage
if (statement.Parameters[0] is BracketParameter bracket)
{
if (bracket.Name.ToLower() == "v")
{
switch (bracket.Parameters.Count)
{
// V(A, B) - V(vector)
// V(A) - V(singleParameter)
case 1:
if (bracket.Parameters[0] is VectorParameter v && v.Elements.Count == 2)
{
var output = v.Elements[0].Image;
var reference = v.Elements[1].Image;
var input = statement.Parameters[2].Image;
noise = new Noise(name, output, reference, input, sweep);
}
else if (bracket.Parameters[0] is SingleParameter s)
{
var output = s.Image;
var input = statement.Parameters[1].Image;
noise = new Noise(name, output, input, sweep);
}
break;
