public Dictionary <string, ResolverFunction> CreateFunctions()
{
var result = new Dictionary <string, ResolverFunction>(StringComparerProvider.Get(Context.CaseSettings.IsFunctionNameCaseSensitive));
foreach (var functionName in Context.FunctionsBody.Keys)
{
var body = Context.FunctionsBody[functionName];
if (body != null)
{
var bodyNode = InternalParser.Parse(body);
result[functionName] = new StaticResolverFunction(
functionName,
bodyNode,
Context.FunctionArguments[functionName].Select(a => Node.Variable(a)).ToList());
}
}
result["poly"] = new PolyResolverFunction();
result["if"] = new IfResolverFunction();
result["max"] = new MaxResolverFunction();
result["random"] = new RandomResolverFunction(Context);
result["gauss"] = new GaussResolverFunction(Context);
return(result);
}
/// <summary>
/// Initializes a new instance of the <see cref="SubcircuitNodeNameGenerator"/> class.
/// </summary>
/// <param name="subcircuitFullName">The fullname of subcircuit.</param>
/// <param name="subCircuitName">The name of subcircuit.</param>
/// <param name="currentSubCircuit">The current subcircuit.</param>
/// <param name="pinInstanceNames">The names of pins.</param>
/// <param name="globals">Global pin names.</param>
/// <param name="isNodeNameCaseSensitive">Is node name case sensitive.</param>
public SubcircuitNodeNameGenerator(string subcircuitFullName, string subCircuitName, SubCircuit currentSubCircuit, List <string> pinInstanceNames, IEnumerable <string> globals, bool isNodeNameCaseSensitive)
{
RootName = subCircuitName ?? throw new ArgumentNullException(nameof(subCircuitName));
FullName = subcircuitFullName ?? throw new ArgumentNullException(nameof(subcircuitFullName));
SubCircuit = currentSubCircuit ?? throw new ArgumentNullException(nameof(currentSubCircuit));
PinInstanceNames = pinInstanceNames ?? throw new ArgumentNullException(nameof(pinInstanceNames));
if (globals == null)
{
throw new ArgumentNullException(nameof(globals));
}
_pinMap = new Dictionary <string, string>(StringComparerProvider.Get(isNodeNameCaseSensitive));
if (SubCircuit.Pins.Count != PinInstanceNames.Count)
{
throw new SpiceSharpParserException($"Subcircuit: {subcircuitFullName} has wrong number of nodes");
}
for (var i = 0; i < SubCircuit.Pins.Count; i++)
{
var pinIdentifier = SubCircuit.Pins[i].Image;
var pinInstanceIdentifier = PinInstanceNames[i];
_pinMap[pinIdentifier] = pinInstanceIdentifier;
}
IsNodeNameCaseSensitive = isNodeNameCaseSensitive;
InitGlobals(globals);
}
public EvaluationContext(
string name,
ISpiceNetlistCaseSensitivitySettings caseSettings,
IRandomizer randomizer,
IExpressionParserFactory expressionParserFactory,
IExpressionFeaturesReader expressionFeaturesReader,
IExpressionValueProvider expressionValueProvider,
INameGenerator nameGenerator,
IResultService resultService)
{
_caseSettings = caseSettings;
ExpressionParserFactory = expressionParserFactory;
ExpressionFeaturesReader = expressionFeaturesReader;
ExpressionValueProvider = expressionValueProvider;
NameGenerator = nameGenerator;
ResultService = resultService;
Name = name;
Parameters = new Dictionary <string, Expression>(StringComparerProvider.Get(caseSettings.IsParameterNameCaseSensitive));
Arguments = new Dictionary <string, Expression>(StringComparerProvider.Get(caseSettings.IsParameterNameCaseSensitive));
Functions = new Dictionary <string, List <IFunction> >(StringComparerProvider.Get(caseSettings.IsFunctionNameCaseSensitive));
Children = new List <EvaluationContext>();
ExpressionRegistry = new ExpressionRegistry(caseSettings.IsParameterNameCaseSensitive, caseSettings.IsExpressionNameCaseSensitive);
FunctionsBody = new Dictionary <string, string>();
FunctionArguments = new Dictionary <string, List <string> >();
Randomizer = randomizer;
}
/// <summary>
/// Sets the base parameters of a simulation.
/// </summary>
/// <param name="baseSimulation">The simulation to configure.</param>
/// <param name="context">The reading context.</param>
protected void ConfigureCommonSettings(BaseSimulation baseSimulation, ICircuitContext context)
{
var baseConfiguration = baseSimulation.Configurations.Get <BaseConfiguration>();
if (context.Result.SimulationConfiguration.Gmin.HasValue)
{
baseConfiguration.Gmin = context.Result.SimulationConfiguration.Gmin.Value;
}
if (context.Result.SimulationConfiguration.AbsoluteTolerance.HasValue)
{
baseConfiguration.AbsoluteTolerance = context.Result.SimulationConfiguration.AbsoluteTolerance.Value;
}
if (context.Result.SimulationConfiguration.RelTolerance.HasValue)
{
baseConfiguration.RelativeTolerance = context.Result.SimulationConfiguration.RelTolerance.Value;
}
if (context.Result.SimulationConfiguration.DCMaxIterations.HasValue)
{
baseConfiguration.DcMaxIterations = context.Result.SimulationConfiguration.DCMaxIterations.Value;
}
baseSimulation.Configurations.Add(
new CollectionConfiguration()
{
VariableComparer = StringComparerProvider.Get(context.CaseSensitivity.IsNodeNameCaseSensitive),
});
}
/// <summary>
/// Initializes a new instance of the <see cref="StochasticModelsRegistry"/> class.
/// </summary>
/// <param name="modelNamesGenerators">The enumerable of model name generators.</param>
/// <param name="isModelNameCaseSensitive">Is model names case sensitive.</param>
public StochasticModelsRegistry(IEnumerable <INameGenerator> modelNamesGenerators, bool isModelNameCaseSensitive)
{
NamesGenerators = modelNamesGenerators ?? throw new ArgumentNullException(nameof(modelNamesGenerators));
IsModelNameCaseSensitive = isModelNameCaseSensitive;
AllModels = new Dictionary <string, Entity>(StringComparerProvider.Get(isModelNameCaseSensitive));
}
static SimpleDerivativeParserExtended()
{
DefaultFunctionsCaseSensitive =
new ConcurrentDictionary <string, SimpleDerivativeParserHelper.DoubleDerivativesFunction>(
StringComparerProvider.Get(true));
DefaultFunctionsCaseInSensitive =
new ConcurrentDictionary <string, SimpleDerivativeParserHelper.DoubleDerivativesFunction>(
StringComparerProvider.Get(false));
var dict = new Dictionary <string, SimpleDerivativeParserHelper.DoubleDerivativesFunction>()
{
{ "Exp", SimpleDerivativeParserHelper.ApplyExp },
{ "Log", SimpleDerivativeParserHelper.ApplyLog },
{ "Pow", SimpleDerivativeParserHelper.ApplyPow },
{ "Log10", SimpleDerivativeParserHelper.ApplyLog10 },
{ "Sqrt", SimpleDerivativeParserHelper.ApplySqrt },
{ "Sin", SimpleDerivativeParserHelper.ApplySin },
{ "Cos", ApplyCos },
{ "Tan", ApplyTan },
{ "Asin", SimpleDerivativeParserHelper.ApplyAsin },
{ "Acos", SimpleDerivativeParserHelper.ApplyAcos },
{ "Atan", SimpleDerivativeParserHelper.ApplyAtan },
{ "Abs", SimpleDerivativeParserHelper.ApplyAbs },
{ "Round", SimpleDerivativeParserHelper.ApplyRound },
{ "Min", SimpleDerivativeParserHelper.ApplyMin },
{ "Max", SimpleDerivativeParserHelper.ApplyMax },
};
foreach (var function in dict)
{
DefaultFunctionsCaseSensitive.TryAdd(function.Key, function.Value);
DefaultFunctionsCaseInSensitive.TryAdd(function.Key, function.Value);
}
}
/// <summary>
/// Returns a value indicating whether the mapper has a element for <paramref name="key"/>.
/// </summary>
/// <param name="key">
/// A key.
/// </param>
/// <param name="caseSensitive">Is key case-sensitive.</param>
/// <returns>
/// A value indicating whether the mapper has a element with given <paramref name="key"/>.
/// </returns>
public bool ContainsKey(string key, bool caseSensitive)
{
if (caseSensitive)
{
return(Elements.ContainsKey(key));
}
return(Elements.Keys.Contains(key, StringComparerProvider.Get(false)));
}
private void InitGlobals(IEnumerable <string> globals)
{
_globals = new HashSet <string>(StringComparerProvider.Get(IsNodeNameCaseSensitive));
foreach (var global in globals)
{
_globals.Add(global);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ExpressionRegistry"/> class.
/// </summary>
/// <param name="isParameterNameCaseSensitive">Is parameter name case-sensitive.</param>
/// <param name="isExpressionNameCaseSensitive">Is expression name case-sensitive.</param>
public ExpressionRegistry(bool isParameterNameCaseSensitive, bool isExpressionNameCaseSensitive)
{
IsExpressionNameCaseSensitive = isExpressionNameCaseSensitive;
IsParameterNameCaseSensitive = isParameterNameCaseSensitive;
NamedExpressions = new Dictionary <string, NamedExpression>(StringComparerProvider.Get(isExpressionNameCaseSensitive));
ParametersExpressionsDependencies = new Dictionary <string, List <Expression> >(StringComparerProvider.Get(isParameterNameCaseSensitive));
ParametersDependencies = new Dictionary <string, HashSet <string> >(StringComparerProvider.Get(isParameterNameCaseSensitive));
UnnamedExpressions = new List <Expression>();
Parameters = new Dictionary <string, Expression>(StringComparerProvider.Get(isParameterNameCaseSensitive));
}
public void SetParameter(Entity entity, string parameterName, Parameter parameter, bool beforeTemperature = true, bool onload = true)
{
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
if (parameterName == null)
{
throw new ArgumentNullException(nameof(parameterName));
}
if (parameter == null)
{
throw new ArgumentNullException(nameof(parameter));
}
string expression = null;
if (parameter is SingleParameter sp)
{
expression = sp.Image;
}
if (parameter is AssignmentParameter asg)
{
expression = asg.Value;
}
IEqualityComparer <string> comparer = StringComparerProvider.Get(CaseSensitivity.IsEntityParameterNameCaseSensitive);
try
{
double value = Evaluator.EvaluateDouble(expression);
entity.SetParameter(parameterName, value, comparer);
var context = Evaluator.GetEvaluationContext();
bool isDynamic = context.HaveSpiceProperties(expression) ||
context.HaveFunctions(expression) ||
context.GetExpressionParameters(expression, false).Any();
if (isDynamic)
{
SimulationPreparations.SetParameter(entity, parameterName, expression, beforeTemperature, onload);
}
}
catch (Exception ex)
{
Result.Validation.Add(new ValidationEntry(ValidationEntrySource.Reader, ValidationEntryLevel.Warning,
$"Exception during evaluation of parameter with expression: `{expression}`: {ex}", parameter.LineInfo));
}
}
public IModelsRegistry CreateChildRegistry(List <INameGenerator> generators)
{
var result = new StochasticModelsRegistry(generators, IsModelNameCaseSensitive)
{
AllModels = new Dictionary <string, Entity>(AllModels, StringComparerProvider.Get(IsModelNameCaseSensitive)),
ModelsWithDev = new Dictionary <Model, Dictionary <Parameter, ParameterRandomness> >(ModelsWithDev),
ModelsWithLot = new Dictionary <Model, Dictionary <Parameter, ParameterRandomness> >(ModelsWithLot),
StochasticModels = new Dictionary <BaseSimulation, Dictionary <Model, List <Model> > >(StochasticModels),
};
return(result);
}
/// <summary>
/// Creates a new current export.
/// </summary>
/// <param name="name">Name of export.</param>
/// <param name="type">A type of export.</param>
/// <param name="parameters">A parameters of export.</param>
/// <param name="context">Expression context.</param>
/// <param name="caseSettings">Case settings.</param>
/// <returns>
/// A new export.
/// </returns>
public override Export CreateExport(string name, string type, ParameterCollection parameters, EvaluationContext context, ISpiceNetlistCaseSensitivitySettings caseSettings)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var comparer = StringComparerProvider.Get(false);
var entityName = (parameters[0] as VectorParameter)?.Elements[0].Image;
var propertyName = (parameters[0] as VectorParameter)?.Elements[1].Image;
if (entityName != null && propertyName != null)
{
if (entityName.Contains("#"))
{
string objectName = $"{context.NameGenerator.GenerateObjectName(entityName)}_{context.Simulation.Name}";
return(new PropertyExport(name, context.Simulation, objectName, propertyName));
}
else
{
string objectName = context.NameGenerator.GenerateObjectName(entityName);
if (context.ResultService.FindObject(objectName, out _))
{
return(new PropertyExport(name, context.Simulation, objectName, propertyName));
}
else
{
return(new PropertyExport(name, context.Simulation, entityName, propertyName));
}
}
}
throw new SpiceSharpParserException("Invalid property export", parameters.LineInfo);
}
private void InitGlobals(IEnumerable <string> globals)
{
if (globals == null)
{
throw new ArgumentNullException(nameof(globals));
}
_globals = new HashSet <string>(StringComparerProvider.Get(IsNodeNameCaseSensitive));
foreach (var global in globals)
{
_globals.Add(global);
}
}
private void SetModelLotModelParameters(Simulation simulation, string baseModel, IEntity componentModel, Dictionary <Parameter, ParameterRandomness> stochasticLotParameters)
{
var comparer = StringComparerProvider.Get(false);
foreach (var stochasticParameter in stochasticLotParameters)
{
var parameter = stochasticParameter.Key;
var parameterPercent = stochasticParameter.Value;
if (parameter is AssignmentParameter asg)
{
var parameterName = asg.Name;
var currentValue = simulation.EntityBehaviors[componentModel.Name].GetProperty <double>(parameterName);
var percentValue = _context.Evaluator.EvaluateDouble(parameterPercent.Tolerance.Image, simulation);
double newValue = GetValueForLotParameter(_context.Evaluator.GetEvaluationContext(simulation), baseModel, parameterName, currentValue, percentValue, parameterPercent.RandomDistributionName, comparer);
_context.SimulationPreparations.SetParameter(componentModel, simulation, parameterName, newValue, true, false);
}
}
}
public void SetParameter(Entity entity, string parameterName, string expression, bool beforeTemperature = true, bool onload = true)
{
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
if (parameterName == null)
{
throw new ArgumentNullException(nameof(parameterName));
}
if (expression == null)
{
throw new ArgumentNullException(nameof(expression));
}
IEqualityComparer <string> comparer = StringComparerProvider.Get(CaseSensitivity.IsEntityParameterNameCaseSensitive);
double value = Evaluator.EvaluateDouble(expression);
try
{
entity.SetParameter(parameterName, value, comparer);
var context = Evaluator.GetEvaluationContext();
bool isDynamic = context.HaveSpiceProperties(expression) ||
context.HaveFunctions(expression) ||
context.GetExpressionParameters(expression, false).Any();
if (isDynamic)
{
SimulationPreparations.SetParameter(entity, parameterName, expression, beforeTemperature, onload);
}
}
catch (Exception e)
{
Result.Validation.Add(new ValidationEntry(ValidationEntrySource.Reader, ValidationEntryLevel.Warning, $"Problem with setting parameter = {parameterName} with value = {value}"));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Randomizer"/> class.
/// </summary>
/// <param name="isDistributionNameCaseSensitive">Is distribution name case-sensitive.</param>
/// <param name="cdfPoints">Number of cdf points.</param>
/// <param name="normalLimit">Normal limit.</param>
/// <param name="seed">Seed.</param>
public Randomizer(
bool isDistributionNameCaseSensitive = false,
int?cdfPoints = null,
double?normalLimit = null,
int?seed = null,
Dictionary <string, Func <Pdf> > pdfDictionary = null,
Dictionary <string, Pdf> pdfInstances = null,
Dictionary <string, Cdf> cdfDictionary = null,
Dictionary <string, CustomRandomNumberProviderFactory> customRandomNumberProviderFactories = null)
{
_isDistributionNameCaseSensitive = isDistributionNameCaseSensitive;
_pdfDictionary = pdfDictionary ?? new Dictionary <string, Func <Pdf> >(StringComparerProvider.Get(isDistributionNameCaseSensitive));
_pdfInstancesDictionary = pdfInstances ?? new Dictionary <string, Pdf>(StringComparerProvider.Get(isDistributionNameCaseSensitive));
_cdfDictionary = cdfDictionary ?? new Dictionary <string, Cdf>(StringComparerProvider.Get(isDistributionNameCaseSensitive));
_customRandomNumberProviderFactories = customRandomNumberProviderFactories ?? new Dictionary <string, CustomRandomNumberProviderFactory>(StringComparerProvider.Get(isDistributionNameCaseSensitive));
CurrentPdfName = null;
CdfPoints = cdfPoints ?? DefaultCdfPoints;
NormalLimit = normalLimit ?? DefaultNormalLimit;
Seed = seed;
RegisterDefaultPdfs();
}
private void SetModelDevModelParameters(BaseSimulation simulation, Entity baseModel, Entity componentModel, Dictionary <Parameter, ParameterRandomness> stochasticDevParameters)
{
var comparer = StringComparerProvider.Get(_context.CaseSensitivity.IsEntityParameterNameCaseSensitive);
foreach (var stochasticParameter in stochasticDevParameters)
{
var parameter = stochasticParameter.Key;
var parameterPercent = stochasticParameter.Value;
if (parameter is AssignmentParameter assignmentParameter)
{
var parameterName = assignmentParameter.Name;
var currentValueParameter = simulation.EntityParameters[componentModel.Name].GetParameter <Parameter <double> >(parameterName, comparer);
var currentValue = currentValueParameter.Value;
var percentValue = _context.Evaluator.EvaluateDouble(parameterPercent.Tolerance.Image, simulation);
var random = _context.Evaluator.GetEvaluationContext(simulation).Randomizer.GetRandomProvider(parameterPercent.RandomDistributionName);
var r = random.NextSignedDouble();
var newValue = currentValue + ((percentValue / 100.0) * currentValue * r);
_context.SimulationPreparations.SetParameter(componentModel, simulation, parameterName, newValue, true, false);
}
}
}
public Node Resolve(string expression)
{
var node = InternalParser.Parse(expression);
try
{
var resolver = new Resolver();
var comparer = StringComparerProvider.Get(CaseSettings.IsParameterNameCaseSensitive);
if (Context.NameGenerator.NodeNameGenerator is SubcircuitNodeNameGenerator)
{
resolver.UnknownVariableFound += (sender, args) =>
{
if (args.Node.NodeType == NodeTypes.Voltage)
{
if (resolver.VariableMap.Any(v => comparer.Equals(v.Key, args.Node.Name)))
{
var node = resolver.VariableMap.First(v => comparer.Equals(v.Key, args.Node.Name)).Value;
args.Result = VariableNode.Voltage(node.ToString());
}
else
{
args.Result = VariableNode.Voltage(Context.NameGenerator.ParseNodeName(args.Node.Name));
}
}
if (args.Node.NodeType == NodeTypes.Current)
{
args.Result = VariableNode.Current(Context.NameGenerator.GenerateObjectName(args.Node.Name));
}
};
}
else
{
resolver.UnknownVariableFound += (sender, args) =>
{
if (args.Node.NodeType == NodeTypes.Voltage)
{
if (resolver.VariableMap.Any(v => comparer.Equals(v.Key, args.Node.Name)))
{
var node = resolver.VariableMap.First(v => comparer.Equals(v.Key, args.Node.Name)).Value;
args.Result = VariableNode.Voltage(node.ToString());
}
else
{
args.Result = VariableNode.Voltage(args.Node.Name);
}
}
if (args.Node.NodeType == NodeTypes.Current)
{
args.Result = VariableNode.Current(args.Node.Name);
}
};
}
resolver.FunctionMap = CreateFunctions();
resolver.VariableMap = new Dictionary <string, Node>(StringComparerProvider.Get(CaseSettings.IsParameterNameCaseSensitive));
foreach (var variable in DoubleBuilder.Variables)
{
if (variable.Constant)
{
resolver.VariableMap[variable.Name] = variable.Value();
}
else
{
resolver.VariableMap[variable.Name] = variable.VariableNode;
}
}
// TIME variable is handled well in SpiceSharpBehavioral
resolver.VariableMap.Remove("TIME");
var resolved = resolver.Resolve(node);
return(resolved);
}
catch (Exception)
{
if (ThrowOnErrors)
{
throw;
}
}
return(node);
}
private void OnVariableFound(object sender, SpiceSharpBehavioral.Builders.Direct.VariableFoundEventArgs <double> e)
{
if (e.Node.NodeType != NodeTypes.Voltage && e.Node.NodeType != NodeTypes.Current && e.Node.NodeType != NodeTypes.Property)
{
var found = Variables.SingleOrDefault(variable => StringComparerProvider.Get(_caseSettings.IsParameterNameCaseSensitive).Equals(variable.Name, e.Node.Name));
if (found != null)
{
e.Result = found.Value();
}
}
else
{
if (Context.Simulation == null)
{
e.Result = 0;
}
else
{
if (e.Node.NodeType == NodeTypes.Current)
{
var name = e.Node.Name;
var parameters = new ParameterCollection();
var vectorParameter = new VectorParameter();
vectorParameter.Elements.Add(new IdentifierParameter(e.Node.Name.ToString()));
parameters.Add(vectorParameter);
string key = $"{Context.Name}_I_{parameters}_{Context.Simulation?.Name}";
if (_exporterInstances.TryGetValue(key, out Export cachedExport))
{
e.Result = cachedExport.Extract();
}
else
{
var currentExporter = new CurrentExporter();
var export = currentExporter.CreateExport(
key,
"I",
parameters,
Context,
_caseSettings);
_exporterInstances[key] = export;
e.Result = export.Extract();
}
}
else if (e.Node.NodeType == NodeTypes.Voltage)
{
var name = e.Node.Name;
var variable = Variables.FirstOrDefault(v => v.Name == name);
if (variable != null)
{
name = variable.Value().ToString();
}
var parameters = new ParameterCollection();
var vectorParameter = new VectorParameter();
vectorParameter.Elements.Add(new IdentifierParameter(name));
parameters.Add(vectorParameter);
string key = $"{Context.Name}_V_{parameters}_{Context.Simulation?.Name}";
if (_exporterInstances.TryGetValue(key, out Export cachedExport))
{
e.Result = cachedExport.Extract();
}
else
{
var currentExporter = new VoltageExporter();
var export = currentExporter.CreateExport(
key,
"V",
parameters,
Context,
_caseSettings);
_exporterInstances[key] = export;
try
{
e.Result = export.Extract();
}
catch (Exception ex)
{
if (ThrowOnErrors)
{
throw;
}
e.Result = 0;
}
}
}
}
}
}
public void Apply(BaseSimulation simulation)
{
if (simulation == null)
{
throw new ArgumentNullException(nameof(simulation));
}
simulation.BeforeLoad += (sender, args) =>
{
foreach (var entity in CommonUpdates.Keys)
{
var beforeLoads = CommonUpdates[entity].ParameterUpdatesBeforeLoad;
foreach (var entityUpdate in beforeLoads)
{
var parameter = GetEntitySimulationParameter(entityUpdate.ParameterName, entity, simulation, StringComparerProvider.Get(IsParameterNameCaseSensitive));
if (parameter != null)
{
Common.Evaluation.EvaluationContext context = GetEntityContext(simulation, entity);
var value = entityUpdate.GetValue(context);
if (!double.IsNaN(value))
{
parameter.Value = value;
}
}
}
}
if (SimulationSpecificUpdates.ContainsKey(simulation))
{
foreach (var entityPair in SimulationSpecificUpdates[simulation])
{
var beforeLoads = entityPair.Value.ParameterUpdatesBeforeLoad;
foreach (var entityUpdate in beforeLoads)
{
var parameter = GetEntitySimulationParameter(entityUpdate.ParameterName, entityPair.Key, simulation, StringComparerProvider.Get(IsParameterNameCaseSensitive));
if (parameter != null)
{
Common.Evaluation.EvaluationContext context = GetEntityContext(simulation, entityPair.Key);
var value = entityUpdate.GetValue(context);
if (!double.IsNaN(value))
{
parameter.Value = value;
}
}
}
}
}
};
simulation.BeforeTemperature += (sender, args) =>
{
foreach (var entity in CommonUpdates.Keys)
{
var beforeTemperature = CommonUpdates[entity].ParameterUpdatesBeforeTemperature;
foreach (var entityUpdate in beforeTemperature)
{
var parameter = GetEntitySimulationParameter(entityUpdate.ParameterName, entity, simulation, StringComparerProvider.Get(IsParameterNameCaseSensitive));
if (parameter != null)
{
Common.Evaluation.EvaluationContext context = GetEntityContext(simulation, entity);
var value = entityUpdate.GetValue(context);
if (!double.IsNaN(value))
{
parameter.Value = value;
}
}
}
}
if (SimulationSpecificUpdates.ContainsKey(simulation))
{
foreach (var entityPair in SimulationSpecificUpdates[simulation])
{
var beforeTemperature = entityPair.Value.ParameterUpdatesBeforeTemperature;
foreach (var entityUpdate in beforeTemperature)
{
var parameter = GetEntitySimulationParameter(entityUpdate.ParameterName, entityPair.Key, simulation, StringComparerProvider.Get(IsParameterNameCaseSensitive));
if (parameter != null)
{
Common.Evaluation.EvaluationContext context = GetEntityContext(simulation, entityPair.Key);
var value = entityUpdate.GetValue(context);
if (!double.IsNaN(value))
{
parameter.Value = value;
}
}
}
}
}
};
}
/// <summary>
/// Gets expression names.
/// </summary>
/// <returns>
/// Enumerable of expression names.
/// </returns>
public HashSet <string> GetExpressionNames()
{
return(new HashSet <string>(NamedExpressions.Keys, StringComparerProvider.Get(IsExpressionNameCaseSensitive)));
}
/// <summary>
/// Translates Netlist object mode to SpiceSharp netlist.
/// </summary>
/// <param name="netlist">A object model of the netlist.</param>
/// <returns>
/// A new SpiceSharp netlist.
/// </returns>
public SpiceModel <SpiceSharp.Circuit, Simulation> Read(SpiceNetlist netlist)
{
if (netlist == null)
{
throw new System.ArgumentNullException(nameof(netlist));
}
// Get result netlist
var result = new SpiceModel <Circuit, Simulation>(
new Circuit(StringComparerProvider.Get(Settings.CaseSensitivity.IsEntityNameCaseSensitive)),
netlist.Title);
// Get reading context
var resultService = new ResultService(result);
var nodeNameGenerator = new MainCircuitNodeNameGenerator(
new [] { "0" },
Settings.CaseSensitivity.IsNodeNameCaseSensitive);
var objectNameGenerator = new ObjectNameGenerator(string.Empty);
INameGenerator nameGenerator = new NameGenerator(nodeNameGenerator, objectNameGenerator);
IRandomizer randomizer = new Randomizer(
Settings.CaseSensitivity.IsDistributionNameCaseSensitive,
seed: Settings.Seed);
IExpressionParserFactory expressionParserFactory = new ExpressionParserFactory(Settings.CaseSensitivity);
IExpressionFeaturesReader expressionFeaturesReader = new ExpressionFeaturesReader(expressionParserFactory);
IExpressionValueProvider expressionValueProvider = new ExpressionValueProvider(expressionParserFactory);
EvaluationContext expressionContext = new SpiceEvaluationContext(
string.Empty,
Settings.EvaluatorMode,
Settings.CaseSensitivity,
randomizer,
expressionParserFactory,
expressionFeaturesReader,
expressionValueProvider,
nameGenerator,
resultService);
var simulationEvaluationContexts = new SimulationEvaluationContexts(expressionContext);
ISimulationPreparations simulationPreparations = new SimulationPreparations(
new EntityUpdates(Settings.CaseSensitivity.IsParameterNameCaseSensitive, simulationEvaluationContexts),
new SimulationsUpdates(simulationEvaluationContexts));
ICircuitEvaluator circuitEvaluator = new CircuitEvaluator(simulationEvaluationContexts, expressionContext);
ISpiceStatementsReader statementsReader = new SpiceStatementsReader(Settings.Mappings.Controls,
Settings.Mappings.Models, Settings.Mappings.Components);
IWaveformReader waveformReader = new WaveformReader(Settings.Mappings.Waveforms);
ICircuitContext circuitContext = new CircuitContext(
"Root circuit context",
null,
circuitEvaluator,
simulationPreparations,
resultService,
nameGenerator,
statementsReader,
waveformReader,
Settings.CaseSensitivity,
Settings.Mappings.Exporters,
Settings.WorkingDirectory,
null);
// Set initial seed
circuitContext.Evaluator.Seed = Settings.Seed;
// Read statements form input netlist using created context
circuitContext.Read(netlist.Statements, Settings.Orderer);
// Set final seed
result.Seed = circuitContext.Evaluator.Seed;
return(result);
}
