public static Tuple <string, double>[] RunOpSimulation(ISpiceModel <Circuit, Simulation> readerResult)
{
var simulation = readerResult.Simulations.First(s => s is OP);
Tuple <string, double>[] result = new Tuple <string, double> [readerResult.Exports.Count];
simulation.ExportSimulationData += (sender, e) =>
{
for (var i = 0; i < readerResult.Exports.Count; i++)
{
var export = readerResult.Exports[i];
try
{
result[i] = new Tuple <string, double>(export.Name, export.Extract());
}
catch
{
result[i] = new Tuple <string, double>(export.Name, double.NaN);
}
}
};
simulation.Run(readerResult.Circuit);
return(result);
}
/// <summary>
/// Runs simulations from collection.
/// </summary>
/// <param name="readerResult">A reader result</param>
/// <returns>
/// A list of exports list
/// </returns>
public static void RunSimulations(ISpiceModel <Circuit, Simulation> readerResult)
{
foreach (var simulation in readerResult.Simulations)
{
simulation.Run(readerResult.Circuit);
}
}
/// <summary>
/// Parses the netlist.
/// </summary>
/// <param name="spiceNetlist">Netlist to parse.</param>
/// <returns>
/// A parsing result.
/// </returns>
public SpiceParserResult ParseNetlist(string spiceNetlist)
{
if (spiceNetlist == null)
{
throw new ArgumentNullException(nameof(spiceNetlist));
}
var result = new SpiceParserResult {
ValidationResult = new SpiceParserValidationResult()
};
// Get tokens
try
{
var tokens = TokenProviderPool.GetSpiceTokenProvider(Settings.Lexing).GetTokens(spiceNetlist);
SpiceNetlist originalNetlistModel = SingleNetlistParser.Parse(tokens);
// Preprocessing
var preprocessedNetListModel = GetPreprocessedNetListModel(originalNetlistModel, result.ValidationResult);
// Reading model
var reader = new SpiceNetlistReader(Settings.Reading);
ISpiceModel <Circuit, Simulation> spiceModel = reader.Read(preprocessedNetListModel);
result.OriginalInputModel = originalNetlistModel;
result.PreprocessedInputModel = preprocessedNetListModel;
result.SpiceModel = spiceModel;
result.ValidationResult.Reading.AddRange(result.SpiceModel.ValidationResult);
}
catch (LexerException e)
{
result.ValidationResult.Lexing.Add(
new ValidationEntry(
ValidationEntrySource.Lexer,
ValidationEntryLevel.Error,
e.ToString(),
null));
}
catch (ParseException e)
{
result.ValidationResult.Parsing.Add(
new ValidationEntry(
ValidationEntrySource.Parser,
ValidationEntryLevel.Error,
e.ToString(),
null));
}
return(result);
}
public static double RunOpSimulation(ISpiceModel <Circuit, Simulation> readerResult, string nameOfExport)
{
double result = double.NaN;
var export = readerResult.Exports.Find(e => e.Name == nameOfExport);
var simulation = readerResult.Simulations.Single();
simulation.ExportSimulationData += (sender, e) =>
{
result = export.Extract();
};
simulation.Run(readerResult.Circuit);
return(result);
}
public static Tuple <double, double>[] RunDCSimulation(ISpiceModel <Circuit, Simulation> readerResult, string nameOfExport)
{
var list = new List <Tuple <double, double> >();
var export = readerResult.Exports.Find(e => e.Name == nameOfExport && e.Simulation is DC);
var simulation = readerResult.Simulations.First(s => s is DC);
simulation.ExportSimulationData += (sender, e) =>
{
list.Add(new Tuple <double, double>(e.SweepValue, export.Extract()));
};
simulation.Run(readerResult.Circuit);
return(list.ToArray());
}
/// <summary>
/// Runs simulations from collection.
/// </summary>
/// <param name="readerResult">A reader result</param>
/// <returns>
/// A list of exports list
/// </returns>
public static List <object> RunSimulationsAndReturnExports(ISpiceModel <Circuit, Simulation> readerResult)
{
var result = new List <object>();
foreach (var export in readerResult.Exports)
{
var simulation = export.Simulation;
if (simulation is DC)
{
var dcResult = new List <double>();
result.Add(dcResult);
simulation.ExportSimulationData += (sender, e) =>
{
dcResult.Add(export.Extract());
};
}
if (simulation is OP)
{
simulation.ExportSimulationData += (sender, e) =>
{
var opResult = export.Extract();
result.Add(opResult);
};
}
if (simulation is Transient)
{
var tranResult = new List <Tuple <double, double> >();
result.Add(tranResult);
simulation.ExportSimulationData += (sender, e) =>
{
tranResult.Add(new Tuple <double, double>(e.Time, export.Extract()));
};
}
}
foreach (var simulation in readerResult.Simulations)
{
simulation.Run(readerResult.Circuit);
}
return(result);
}
public static double[] RunOpSimulation(ISpiceModel <Circuit, Simulation> readerResult, params string[] nameOfExport)
{
var simulation = readerResult.Simulations.Single();
double[] result = new double[nameOfExport.Length];
simulation.ExportSimulationData += (sender, e) =>
{
for (var i = 0; i < nameOfExport.Length; i++)
{
var export = readerResult.Exports.Find(exp => exp.Name == nameOfExport[i]);
result[i] = export.Extract();
}
};
simulation.Run(readerResult.Circuit);
return(result);
}
public void OptionsSeedOverridesParsingSeed()
{
ISpiceModel <Circuit, Simulation> parseResult2223 = null;
ISpiceModel <Circuit, Simulation> parseResult2224 = null;
var resultsSeed2223 = new List <double>();
var resultsSeed2224 = new List <double>();
int n = 5;
for (var i = 0; i < n; i++)
{
parseResult2223 = ParseNetlist(
1111,
"Random - Seed test circuit",
"V1 0 1 100",
"R1 1 0 {R+N}",
".OP",
".SAVE i(R1) @R1[resistance]",
".PARAM N=0",
".PARAM R={random() * 1000}",
".STEP PARAM N LIST 2 3",
".OPTIONS SEED = 2223",
".END");
var exports = RunSimulationsAndReturnExports(parseResult2223);
resultsSeed2223.Add((double)exports[0]);
}
for (var i = 0; i < n; i++)
{
parseResult2224 = ParseNetlist(
1111,
"Random - Seed test circuit",
"V1 0 1 100",
"R1 1 0 {R+N}",
".OP",
".SAVE i(R1) @R1[resistance]",
".PARAM N=0",
".PARAM R={random() * 1000}",
".STEP PARAM N LIST 2 3",
".OPTIONS SEED = 2224",
".END");
var exports = RunSimulationsAndReturnExports(parseResult2224);
resultsSeed2224.Add((double)exports[0]);
}
for (var i = 0; i < n; i++)
{
Assert.Equal(resultsSeed2223[0], resultsSeed2223[i]);
}
for (var i = 0; i < n; i++)
{
Assert.Equal(resultsSeed2224[0], resultsSeed2224[i]);
}
Assert.NotEqual(resultsSeed2224[0], resultsSeed2223[0]);
Assert.Equal(2223, parseResult2223?.Seed);
Assert.Equal(2224, parseResult2224?.Seed);
}
