/// <summary>
/// Extract the data
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
public override double Extract(SimulationData data)
{
IParameterized c = (IParameterized)data.GetObject(Component);
return(c.Ask(Parameter, data.Circuit));
// return c.Ask(Parameter);
}
public static T AddParameterWithNullValue <T>(this IParameterized <T> parameterized, string typeName, string parameterName = null, int index = -1)
where T : BuilderBase <T>, IParameterized <T>
{
var parameter = GetParameter(parameterized.Parent, typeName, parameterName)
.WithNullDefault();
return(parameterized.AddParameterInternal(parameter, index));
}
public static T AddParameter <T>(this IParameterized <T> parameterized, IParameterSymbol parameter)
where T : BuilderBase <T>, IParameterized <T>
{
if (parameter.HasExplicitDefaultValue)
{
return(parameterized.AddParameterWithDefaultValue(parameter.Type, parameter.Name, parameter.ExplicitDefaultValue));
}
return(parameterized.AddParameter(parameter.Type, parameter.Name));
}
/// <summary>
/// Copy the DC parameter back to the object
/// </summary>
/// <param name="obj"></param>
/// <param name="par"></param>
private void SetDcParameter(IParameterized obj, Parameter par)
{
if (obj is Voltagesource vsource)
{
vsource.VSRCdcValue.CopyFrom(par);
}
if (obj is Currentsource isource)
{
isource.ISRCdcValue.CopyFrom(par);
}
}
/// <summary>
/// Get the DC parameter
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
private Parameter GetDcParameter(IParameterized obj)
{
if (obj is Voltagesource vsource)
{
return(vsource.VSRCdcValue);
}
if (obj is Currentsource isource)
{
return(isource.ISRCdcValue);
}
return(null);
}
public static bool Matches(this IParameterized parameterized, string name, int paramCount, out string error)
{
int amountOfParameters1 = parameterized.MinAmountOfParameters;
int amountOfParameters2 = parameterized.MaxAmountOfParameters;
if (amountOfParameters1 != -1 && amountOfParameters2 != -1 && paramCount.IsInRange(amountOfParameters1, amountOfParameters2) || (amountOfParameters1 == -1 && paramCount <= amountOfParameters2 || amountOfParameters2 == -1 && paramCount >= amountOfParameters1) || amountOfParameters1 == -1 && amountOfParameters2 == -1)
{
error = string.Empty;
return(true);
}
string str = amountOfParameters1 != -1 ? (amountOfParameters2 != -1 ? (amountOfParameters1 != amountOfParameters2 ? "range {1}-{2}" : "{1}") : "minimun of {2}") : "maximun of {1}";
error = string.Format("{0} requires " + str + " parameters", (object)name, (object)amountOfParameters1, (object)amountOfParameters2);
return(false);
}
public static T AddParameters <T>(this IParameterized <T> parameterized, IEnumerable <IParameterSymbol> parameters)
where T : BuilderBase <T>, IParameterized <T>
{
if (parameters is null || !parameters.Any())
{
return(parameterized.Parent);
}
foreach (var parameter in parameters)
{
parameterized.AddParameter(parameter);
}
return(parameterized.Parent);
}
/// <summary>
/// Test the parameters of a parameterized object
/// </summary>
/// <param name="obj">The parameterized object</param>
/// <param name="names">The parameter names</param>
/// <param name="values">The expected parameter values</param>
protected void TestParameters(IParameterized p, string[] names, double[] values)
{
if (names.Length != values.Length)
{
throw new Exception("Unit test error: parameter name array does not match the value array");
}
// Test all parameters
for (int i = 0; i < names.Length; i++)
{
double expected = values[i];
double actual = p.Ask(names[i]);
double tol = Math.Min(Math.Abs(expected), Math.Abs(actual)) * 1e-6;
Assert.AreEqual(expected, actual, tol);
}
}
/// <summary>
/// Read
/// </summary>
/// <param name="name">The type of the waveform</param>
/// <param name="parameters">Parameters</param>
/// <param name="netlist">The netlist</param>
/// <returns></returns>
public override bool Read(string type, Statement st, Netlist netlist)
{
IParameterized w = Generate(type);
if (st.Parameters.Count > keys.Length)
{
throw new ParseException(st.Name, $"Too many arguments for waveform \"{st.Name.image}\"");
}
for (int i = 0; i < st.Parameters.Count; i++)
{
w.Set(keys[i], netlist.ParseDouble(st.Parameters[i]));
}
Generated = w;
return(true);
}
private static T AddParameterInternal <T>(this IParameterized <T> parameterized, ParameterBuilder <T> parameter, int index)
where T : BuilderBase <T>, IParameterized <T>
{
if (parameterized.Parameters.Any(p => p.Type == parameter.Type && p.Name == parameter.Name))
{
return(parameterized.Parent);
}
if (index > -1)
{
parameterized.Parameters.Insert(index, parameter);
}
else
{
parameterized.Parameters.Add(parameter);
}
return(parameterized.Parent);
}
public string Set(IParameterized setter, int index, object value)
{
if (_disabled)
{
if (value is string str)
{
return("\"" + str.Replace("\"", "\\\"") + "\"");
}
if (value is bool b)
{
return(b ? "true" : "false");
}
return(value?.ToString() ?? "null");
}
var key = setter.ParameterName + (index >= 0 ? "_" + index : "");
Parameters[key] = value;
return($"p.{key}");
}
public string SetMany(IParameterized setter, params object[] parameters)
{
if (_disabled)
{
return("[" + string.Join(", ", parameters.Select(parameter =>
{
if (parameter is string str)
{
return "\"" + str.Replace("\"", "\\\"") + "\"";
}
if (parameter is bool b)
{
return b ? "true" : "false";
}
return parameter?.ToString() ?? "null";
})) + "]");
}
var key = setter.ParameterName;
Parameters[key] = parameters;
return($"p.{key}");
}
/// <summary>
/// Read named parameters for a Parameterized object
/// </summary>
/// <param name="obj">The parameterized object</param>
/// <param name="parameters">The parameters</param>
/// <param name="start">The starting index</param>
public static void ReadParameters(this Netlist netlist, IParameterized obj, List <Token> parameters, int start = 0)
{
for (int i = start; i < parameters.Count; i++)
{
if (parameters[i].kind == TokenConstants.ASSIGNMENT)
{
AssignmentToken at = parameters[i] as AssignmentToken;
string pname;
if (at.Name.kind == WORD)
{
pname = at.Name.image.ToLower();
}
else
{
throw new ParseException(parameters[i], "Invalid assignment");
}
switch (at.Value.kind)
{
case VALUE:
obj.Set(pname, netlist.Readers.ParseDouble(at.Value.image.ToLower()));
break;
case EXPRESSION:
obj.Set(pname, netlist.Readers.ParseDouble(at.Value.image.Substring(1, at.Value.image.Length - 2).ToLower()));
break;
case WORD:
case STRING:
obj.Set(pname, netlist.ParseString(at.Value));
break;
default:
throw new ParseException(parameters[i], "Invalid assignment");
}
}
}
}
public static T AddParameter <T>(this IParameterized <T> parameterized, ITypeSymbol typeSymbol, string parameterName)
where T : BuilderBase <T>, IParameterized <T>
{
parameterized.Parent.AddNamespaceImport(typeSymbol);
return(parameterized.AddParameter(typeSymbol.Name, parameterName));
}
public static T AddParameter <T>(this IParameterized <T> parameterized, string typeName, string parameterName, int index)
where T : BuilderBase <T>, IParameterized <T>
{
return(parameterized.AddParameterInternal(GetParameter(parameterized.Parent, typeName, parameterName), index));
}
public static T AddParameterWithNullValue <T>(this IParameterized <T> parameterized, ITypeSymbol typeSymbol, string parameterName = null, int index = -1)
where T : BuilderBase <T>, IParameterized <T>
{
parameterized.Parent.AddNamespaceImport(typeSymbol);
return(parameterized.AddParameterWithNullValue(typeSymbol.Name, parameterName, index));
}
/// <summary>
/// Execute the DC simulation
/// </summary>
/// <param name="ckt">The circuit</param>
public override void Execute(Circuit ckt)
{
// Setup the state
var state = ckt.State;
var rstate = state.Real;
var config = CurrentConfig;
state.Initialize(ckt);
state.UseIC = false; // UseIC is only used in transient simulations
state.UseDC = true;
state.UseSmallSignal = false;
state.Domain = CircuitState.DomainTypes.None;
state.Gmin = config.Gmin;
// Initialize
IParameterized[] components = new IParameterized[Sweeps.Count];
Parameter[] parameters = new Parameter[Sweeps.Count];
// Initialize first time
for (int i = 0; i < Sweeps.Count; i++)
{
// Get the component to be swept
var sweep = Sweeps[i];
if (!ckt.Objects.Contains(sweep.ComponentName))
{
throw new CircuitException($"Could not find source {sweep.ComponentName}");
}
components[i] = (IParameterized)ckt.Objects[sweep.ComponentName];
// Get the parameter and save it for restoring later
parameters[i] = (Parameter)GetDcParameter(components[i]).Clone();
// Start with the original values
sweep.SetCurrentStep(0);
components[i].Set("dc", sweep.CurrentValue);
}
Initialize(ckt);
// Execute the sweeps
int level = Sweeps.Count - 1;
while (level >= 0)
{
// Fill the values with start values
while (level < Sweeps.Count - 1)
{
level++;
Sweeps[level].SetCurrentStep(0);
components[level].Set("dc", Sweeps[level].CurrentValue);
}
// Calculate the solution
if (!Iterate(config, ckt, config.SweepMaxIterations))
{
IterationFailed?.Invoke(this, ckt);
Op(config, ckt, config.DcMaxIterations);
}
// Export data
Export(ckt);
// Remove all values that are greater or equal to the maximum value
while (level >= 0 && Sweeps[level].CurrentStep >= Sweeps[level].Limit)
{
level--;
}
// Go to the next step for the top level
if (level >= 0)
{
Sweeps[level].SetCurrentStep(Sweeps[level].CurrentStep + 1);
components[level].Set("dc", Sweeps[level].CurrentValue);
}
}
// Restore all the parameters of the swept components
for (int i = 0; i < Sweeps.Count; i++)
{
SetDcParameter(components[i], parameters[i]);
}
Finalize(ckt);
}
public static T AddParameter <T>(this IParameterized <T> parameterized, string typeName)
where T : BuilderBase <T>, IParameterized <T>
{
return(parameterized.AddParameterInternal(GetParameter(parameterized.Parent, typeName, null), -1));
}
/// <summary>
/// Ask a component parameter using the circuit
/// </summary>
/// <param name="component">The component name</param>
/// <param name="parameter">The parameter name</param>
/// <returns></returns>
public double Ask(CircuitIdentifier component, string parameter)
{
IParameterized p = (IParameterized)Circuit.Objects[component];
return(p.Ask(parameter, Circuit));
}
