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