/// <summary>Creates instance of specific analysis model from given circuit definition.</summary>
/// <param name="definition"></param>
/// <returns></returns>
public static TAnalysisModel GetAnalysisModel <TAnalysisModel>(this ICircuitDefinition definition)
{
if (definition == null)
{
throw new ArgumentNullException(nameof(definition));
}
return(AnalysisModelCreator.Instance.Create <TAnalysisModel>(definition));
}
/// <summary>Creates new instance of analysis model of type <see cref="TAnalysisModel" /> for given circuit.</summary>
/// <param name="circuitDefinition">Definition of the circuit.</param>
/// <returns></returns>
public TAnalysisModel Create(ICircuitDefinition circuitDefinition)
{
var instantiationContext =
new ModelInstantiationContext <TAnalysisModel>(modelCreators, paramCreators, circuitDefinition);
var analysisModel = NewInstance(instantiationContext);
return(analysisModel);
}
resolutionCache; // cached models so we can compose arbitrary object graph.
public ModelInstantiationContext(
Dictionary <Type, Func <ICircuitDefinitionDevice, IModelInstantiationContext <TAnalysisModel>,
IAnalysisDeviceModel <TAnalysisModel> > > modelCreators,
Dictionary <Type, Func <object, IModelInstantiationContext <TAnalysisModel>, object> > paramCreators,
ICircuitDefinition circuitDefinition)
{
this.paramCreators = paramCreators;
this.modelCreators = modelCreators;
CircuitDefinition = circuitDefinition;
resolutionCache = new Dictionary <ICircuitDefinitionDevice, IAnalysisDeviceModel <TAnalysisModel> >();
namedDevices = circuitDefinition.Devices.Where(e => e.Tag != null).ToDictionary(e => e.Tag);
}
/// <summary>Performs the simulation and prints results to specified TextWriter.</summary>
/// <param name="circuit">Circuit on which analysis should be performed.</param>
/// <param name="printStatements">Set of all requested print statements that were requested in SPICE input file.</param>
/// <param name="output">TextWriter instance to which the results should be written.</param>
public void Simulate(ICircuitDefinition circuit, IEnumerable <PrintStatement> printStatements, TextWriter output)
{
output.WriteLine(".OP");
var model = circuit.GetLargeSignalModel();
var prints = printStatements.OfType <PrintStatement <LargeSignalCircuitModel> >()
.Where(s => s.AnalysisType == "OP").ToList();
model.EstablishDcBias();
if (prints.Count == 0)
{
// print all values from the circuit that are available.
for (var i = 1; i < model.NodeCount; i++) // no need to print ground voltage
{
output.WriteLine($"V({nodeNames[i]}) = {model.NodeVoltages[i]}");
}
foreach (var device in model.Devices)
{
var providers = device.GetDeviceStateProviders();
if (providers.Any())
{
output.WriteLine(); // separate from previous data
}
foreach (var provider in providers)
{
output.WriteLine($"{provider.Name}({device.DefinitionDevice.Tag}) = {provider.GetValue()}");
}
}
}
else // only requested values
{
var errors = prints.SelectMany(pr => pr.Initialize(model)).ToList();
if (errors.Count > 0)
{
throw new PrinterInitializationException(errors);
}
foreach (var statement in prints)
{
output.Write($"{statement.Header} = ");
statement.PrintValue(output);
output.WriteLine();
}
}
}
public SpiceNetlistParserResult(string title, ICircuitDefinition circuit,
IReadOnlyList <SpiceStatement> otherStatements,
IReadOnlyList <SpiceParserError> errors,
IEnumerable <ISubcircuitDefinition> subcircuits, IReadOnlyList <string> nodeNames,
IReadOnlyDictionary <Type, IReadOnlyDictionary <string, object> > models)
{
CircuitDefinition = circuit;
Errors = errors;
Subcircuits = subcircuits;
NodeNames = nodeNames;
Models = models;
Title = title;
OtherStatements = otherStatements;
NodeIds = new Dictionary <string, int>(nodeNames.Count);
for (var i = 0; i < nodeNames.Count; i++)
{
NodeIds[nodeNames[i]] = i;
}
}
/// <summary>Performs the simulation and prints results to specified TextWriter.</summary>
/// <param name="circuit">Circuit on which analysis should be performed.</param>
/// <param name="printStatements">Set of all requested print statements that were requested in SPICE input file.</param>
/// <param name="output">TextWriter instance to which the results should be written.</param>
public void Simulate(ICircuitDefinition circuit, IEnumerable <PrintStatement> printStatements, TextWriter output)
{
var printers = printStatements.OfType <PrintStatement <LargeSignalCircuitModel> >()
.Where(st => st.AnalysisType == "TRAN").ToList();
var model = circuit.GetLargeSignalModel();
output.WriteLine($".TRAN {param.TimeStep} {param.StopTime} {param.StartTime}");
if (printers.Count == 0) // if no printer here, print all data
{
GetPrintersForAll(model, printers);
}
var errors = printers.SelectMany(pr => pr.Initialize(model)).ToList();
if (errors.Count > 0)
{
throw new PrinterInitializationException(errors);
}
model.EstablishDcBias();
var time = param.StartTime;
PrintHeader(model, printers, output);
PrintValues(model, printers, output);
while (time < param.StopTime)
{
model.AdvanceInTime(param.TimeStep);
time += param.TimeStep;
if (!(time < param.StartTime))
{
PrintValues(model, printers, output);
}
}
}
/// <summary>Creates analysis-specific model of given type using registered factory instance.</summary>
/// <typeparam name="TAnalysisModel">Analysis-specific model type.</typeparam>
/// <param name="circuitDefinition">Definition of the circuit, whose analysis model should be created</param>
/// <returns></returns>
public TAnalysisModel Create <TAnalysisModel>(ICircuitDefinition circuitDefinition)
{
var factory = GetFactory <TAnalysisModel>();
return(factory.Create(circuitDefinition));
}
