/// <summary>
/// Constructor
/// </summary>
/// <param name="definition">The definition</param>
/// <param name="name">Name identifier</param>
public Subcircuit(SubcircuitDefinition definition, CircuitIdentifier name, List <CircuitIdentifier> pins, Dictionary <CircuitIdentifier, Token> parameters = null)
{
Definition = definition;
Name = name;
Pins = pins;
Parameters = parameters;
}
/// <summary>
/// Find the nodemap for a subcircuit definition
/// </summary>
/// <param name="definition">Subcircuit definition</param>
/// <param name="pins">The new pins</param>
/// <returns></returns>
private Dictionary <CircuitIdentifier, CircuitIdentifier> GenerateNodeMap(SubcircuitDefinition definition, List <CircuitIdentifier> pins)
{
// Initialize
Dictionary <CircuitIdentifier, CircuitIdentifier> nodemap = new Dictionary <CircuitIdentifier, CircuitIdentifier>();
// This is actually simple, just a one on one relation
for (int i = 0; i < pins.Count; i++)
{
nodemap.Add(definition.Pins[i], pins[i]);
}
return(nodemap);
}
/// <summary>
/// Find a subcircuit definition using the current scope rules
/// </summary>
/// <param name="id">Subcircuit definition identifier</param>
/// <returns></returns>
public SubcircuitDefinition FindDefinition(Dictionary <CircuitIdentifier, SubcircuitDefinition> definitions, CircuitIdentifier id)
{
SubcircuitDefinition result = null;
CircuitIdentifier orig = id;
switch (DefinitionScope)
{
case ScopeRule.Descend:
while (id != null)
{
// Try to find the definition
if (definitions.TryGetValue(id, out result))
{
return(result);
}
// Not found, go to the parent path
id = id.Shrink();
}
break;
case ScopeRule.GlobalLocal:
// Try to find the definition locally
if (definitions.TryGetValue(id, out result))
{
return(result);
}
// Try to find the definition globally
if (id.Path.Length > 1)
{
id = new CircuitIdentifier(id.Name);
if (definitions.TryGetValue(id, out result))
{
return(result);
}
}
break;
}
throw new ParseException($"Cannot find subcircuit \"{orig}\"");
}
/// <summary>
/// Constructor when reading subcircuit definitions
/// </summary>
/// <param name="parent">Parent path</param>
/// <param name="definition">Subcircuit definition</param>
public SubcircuitPath(SubcircuitPath parent, SubcircuitDefinition definition)
{
// Same global parameters
globalparameters = parent.globalparameters;
// No parameters or instances
Parameters = null; // Should not be used!
InstancePath = null;
// Build the definition path
if (parent.DefinitionPath != null)
{
DefinitionPath = parent.DefinitionPath.Grow(definition.Name.Name);
}
else
{
DefinitionPath = definition.Name;
}
// No node map
NodeMap = null; // Should not be used!
}
/// <summary>
/// Find the parameters
/// </summary>
/// <param name="definition">Subcircuit definition</param>
/// <param name="parameters">Parameters</param>
/// <returns></returns>
private Dictionary <CircuitIdentifier, double> GenerateParameters(Netlist netlist, SubcircuitDefinition definition, Dictionary <CircuitIdentifier, Token> parameters)
{
// Our new parameters
Dictionary <CircuitIdentifier, double> np = new Dictionary <CircuitIdentifier, double>();
// Add local parameters
if (parameters != null)
{
foreach (var item in parameters)
{
np.Add(item.Key, netlist.ParseDouble(item.Value));
}
}
// Add default parameters
if (definition.Defaults != null)
{
foreach (var item in definition.Defaults)
{
if (!np.ContainsKey(item.Key))
{
np.Add(item.Key, netlist.ParseDouble(item.Value));
}
}
}
// Other parameters
if (Parameters != null)
{
switch (ParameterScope)
{
case ScopeRule.Descend:
// Copy all parameters from the previous node
foreach (var item in Parameters)
{
if (!np.ContainsKey(item.Key))
{
np.Add(item.Key, item.Value);
}
}
break;
case ScopeRule.GlobalLocal:
// Only copy the global parameters
foreach (var item in globalparameters)
{
if (!np.ContainsKey(item.Key))
{
np.Add(item.Key, item.Value);
}
}
break;
}
}
// Return results
return(np);
}
