public override void Evaluate <T>(
ICircuitEvaluator <T> evaluator,
EvaluationState <T> evaluationState,
CircuitContext circuitContext)
{
evaluationState.SetGateEvaluationValue(this, evaluationState.GetInput(Context.TypeUniqueId));
}
public override SpiceSharp.Components.Component Generate(string componentIdentifier, string originalName, string type, ParameterCollection parameters, ICircuitContext context)
{
SubCircuit subCircuitDefinition = FindSubcircuitDefinition(parameters, context);
CircuitContext subCircuitContext = CreateSubcircuitContext(componentIdentifier, originalName, subCircuitDefinition, parameters, context);
var ifPreprocessor = new IfPreprocessor();
ifPreprocessor.CaseSettings = subCircuitContext.CaseSensitivity;
ifPreprocessor.Validation = new SpiceParserValidationResult()
{
Reading = context.Result.Validation
};
ifPreprocessor.EvaluationContext = subCircuitContext.Evaluator.GetEvaluationContext();
subCircuitDefinition.Statements = ifPreprocessor.Process(subCircuitDefinition.Statements);
ReadParamControl(subCircuitDefinition, subCircuitContext);
ReadFuncControl(subCircuitDefinition, subCircuitContext);
ReadSubcircuits(subCircuitDefinition, subCircuitContext);
CreateSubcircuitModels(subCircuitDefinition, subCircuitContext); // TODO: Share models someday between instances of subcircuits
CreateSubcircuitComponents(subCircuitDefinition, subCircuitContext);
context.Children.Add(subCircuitContext);
// null is intentional
return(null);
}
private void UpdateContext(CircuitContext context)
{
if (_context == null)
{
_context = context;
}
}
/// <inheritdoc />
public override void Register(CircuitContext context, IDiagnosticHandler diagnostics)
{
if (Fix)
{
RegisterFixed(context, diagnostics);
return;
}
var map = context.Nodes.Shorts;
var ckt = context.Circuit;
string x = map[X];
string ox = map[_origin.X];
string y = map[Y];
string oy = map[_origin.Y];
var direction = _origin is ITransformingDrawable tfd?tfd.TransformNormal(Direction) : Direction;
direction = direction.Order(ref ox, ref x, ref oy, ref y);
// If we only work along one axis, we can simplify the schematic
if (x == ox)
{
MinimumConstraint.AddMinimum(ckt, Y, oy, y, MinimumOffset);
return;
}
if (y == oy)
{
MinimumConstraint.AddMinimum(ckt, X, ox, x, MinimumOffset);
return;
}
// General case, both X and Y are different
AddControlledMinimum(ckt, $"{Owner.Name}[{Name}]", ox, x, oy, y, direction);
MinimumConstraint.AddMinimum(ckt, $"{Owner.Name}[{Name}].min.x", ox, x, direction.X * MinimumOffset);
MinimumConstraint.AddMinimum(ckt, $"{Owner.Name}[{Name}].min.y", oy, y, direction.Y * MinimumOffset);
}
public void testStorage()
{
using (var db = new CircuitContext())
{
Circuit circuit = new Circuit();
Connection con0 = new Connection(); // GND
Connection con1 = new Connection();
Connection con2 = new Connection();
Component battery = new Component(con0, con1, 0, 12);
Component resistor1 = new Component(con0, con2, 2, 0);
Component resistor2 = new Component(con1, con2, 2, 0);
Component resistor3 = new Component(con1, con2, 2, 0);
circuit.AddComponent(battery);
circuit.AddComponent(resistor1);
circuit.AddComponent(resistor2);
circuit.AddComponent(resistor3);
db.Circuits.Add(circuit);
}
}
public int EvaluateNotGate(int value, GateContext gateContext, CircuitContext circuitContext)
{
int layerIndex = value;
GetLayerStatisticsBuilder(layerIndex).AddLinearGate();
UpdateContext(circuitContext);
return(layerIndex);
}
public override void Evaluate <T>(
ICircuitEvaluator <T> evaluator,
EvaluationState <T> evaluationState,
CircuitContext circuitContext)
{
T value = evaluator.EvaluateNotGate(
evaluationState.GetGateEvaluationValue(_inputGate),
Context,
circuitContext
);
evaluationState.SetGateEvaluationValue(this, value);
}
/// <inheritdoc />
public void Update(IBiasingSimulationState state, CircuitContext context, IDiagnosticHandler diagnostics)
{
double x = 0, y = 0;
if (state.TryGetValue(context.Nodes.Shorts[X], out var xValue))
{
x = xValue.Value;
}
if (state.TryGetValue(context.Nodes.Shorts[Y], out var yValue))
{
y = yValue.Value;
}
Location = new(x, y);
}
public T[] EvaluateAndGateBatch(GateEvaluationInput <T>[] evaluationInputs, CircuitContext circuitContext)
{
T[] outputValues = new T[evaluationInputs.Length];
for (int i = 0; i < evaluationInputs.Length; ++i)
{
GateEvaluationInput <T> evaluationInput = evaluationInputs[i];
outputValues[i] = _innerEvaluator.EvaluateAndGate(
evaluationInput.LeftValue,
evaluationInput.RightValue,
evaluationInput.Context,
circuitContext
);
}
return(outputValues);
}
private void RegisterFixed(CircuitContext context, IDiagnosticHandler diagnostics)
{
// No need to go through all these difficult things, let's just apply directly
var map = context.Nodes.Shorts;
string x = map[X];
string ox = map[_origin.X];
string y = map[Y];
string oy = map[_origin.Y];
var direction = _origin is ITransformingDrawable tfd?tfd.TransformNormal(Direction) : Direction;
direction = direction.Order(ref ox, ref x, ref oy, ref y);
if (x != ox)
{
OffsetConstraint.AddOffset(context.Circuit, X, ox, x, direction.X * MinimumOffset);
}
if (y != oy)
{
OffsetConstraint.AddOffset(context.Circuit, Y, oy, y, direction.Y * MinimumOffset);
}
}
/// <inheritdoc />
public override void Register(CircuitContext context, IDiagnosticHandler diagnostics)
{
Vector2 offset = _origin is ITransformingDrawable tfd?tfd.TransformOffset(Offset) : Offset;
var map = context.Nodes.Shorts;
string x = map[X];
string ox = map[_origin.X];
string y = map[Y];
string oy = map[_origin.Y];
if (x != ox)
{
string i = $"{X}.i";
context.Circuit.Add(new Resistor($"R{X}", i, x, 1e-3));
context.Circuit.Add(new VoltageSource($"V{X}", i, ox, offset.X));
}
if (y != oy)
{
string i = $"{Y}.i";
context.Circuit.Add(new Resistor($"R{Y}", i, y, 1e-3));
context.Circuit.Add(new VoltageSource($"V{Y}", y, oy, offset.Y));
}
}
/// <inheritdoc />
public override void Register(CircuitContext context, IDiagnosticHandler diagnostics)
{
// Left to whoever owns this pin...
}
public async Task <Bit> EvaluateXorGate(Task <Bit> leftValue, Task <Bit> rightValue, GateContext gateContext, CircuitContext circuitContext)
{
Bit leftShare = await leftValue.ConfigureAwait(false);
Bit rightShare = await rightValue.ConfigureAwait(false);
return(leftShare ^ rightShare);
}
public async Task <Bit> EvaluateNotGate(Task <Bit> value, GateContext gateContext, CircuitContext circuitContext)
{
Bit share = await value.ConfigureAwait(false);
if (_session.LocalParty.IsFirstParty())
{
return(~share);
}
return(share);
}
public Task <Bit>[] EvaluateAndGateBatch(GateEvaluationInput <Task <Bit> >[] evaluationInputs, CircuitContext circuitContext)
{
return(EvaluateAndGateBatchAsync(evaluationInputs, circuitContext).ToSubTasks(bits => bits.ToArray(), evaluationInputs.Length));
}
private async Task <BitArray> EvaluateAndGateBatchAsync(GateEvaluationInput <Task <Bit> >[] evaluationInputs, CircuitContext circuitContext)
{
int numberOfInvocations = evaluationInputs.Length;
BitArray leftShares = new BitArray(numberOfInvocations);
BitArray rightShares = new BitArray(numberOfInvocations);
for (int i = 0; i < numberOfInvocations; ++i)
{
leftShares[i] = await evaluationInputs[i].LeftValue.ConfigureAwait(false);
rightShares[i] = await evaluationInputs[i].RightValue.ConfigureAwait(false);
}
BitArray multiplicativeShares = await _multiplicativeSharing.ComputeMultiplicativeSharesAsync(_session, leftShares, rightShares, numberOfInvocations);
#if DEBUG
Console.WriteLine(
"Evaluated AND gates {0} of {1} total.",
String.Join(", ", evaluationInputs.Select(input => input.Context.TypeUniqueId + 1)),
circuitContext.NumberOfAndGates
);
#endif
return(multiplicativeShares);
}
public ForwardGate EvaluateNotGate(ForwardGate inputGate, GateContext gateContext, CircuitContext circuitContext)
{
ForwardGate gate = new ForwardNotGate(gateContext);
inputGate.AddSuccessor(gate);
return(gate);
}
public void SendOutputValue <T>(T value, IBatchCircuitEvaluator <T> evaluator, ForwardEvaluationState <T> evaluationState, CircuitContext circuitContext)
{
foreach (ForwardGate successor in _successors)
{
successor.ReceiveInputValue(value, evaluator, evaluationState, circuitContext);
}
}
public T EvaluateXorGate(T leftValue, T rightValue, GateContext gateContext, CircuitContext circuitContext)
{
return(_innerEvaluator.EvaluateXorGate(leftValue, rightValue, gateContext, circuitContext));
}
protected override void ReceiveInputValues <T>(T leftValue, T rightValue, IBatchCircuitEvaluator <T> evaluator, ForwardEvaluationState <T> evaluationState, CircuitContext circuitContext)
{
T outputValue = evaluator.EvaluateXorGate(leftValue, rightValue, _context, circuitContext);
SendOutputValue(outputValue, evaluator, evaluationState, circuitContext);
}
public int EvaluateXorGate(int leftValue, int rightValue, GateContext gateContext, CircuitContext circuitContext)
{
int layerIndex = Math.Max(leftValue, rightValue);
GetLayerStatisticsBuilder(layerIndex).AddLinearGate();
UpdateContext(circuitContext);
return(layerIndex);
}
protected override void ReceiveInputValues <T>(T leftValue, T rightValue, IBatchCircuitEvaluator <T> evaluator, ForwardEvaluationState <T> evaluationState, CircuitContext circuitContext)
{
GateEvaluationInput <T> evaluationInput = new GateEvaluationInput <T>(_context, leftValue, rightValue);
evaluationState.DelayAndGateEvaluation(new GateEvaluation <T>(this, evaluationInput));
}
/// <inheritdoc /> public abstract void Register(CircuitContext context, IDiagnosticHandler diagnostics);
/// <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);
}
public override void ReceiveInputValue <T>(T value, IBatchCircuitEvaluator <T> evaluator, ForwardEvaluationState <T> evaluationState, CircuitContext circuitContext)
{
T outputValue = evaluator.EvaluateNotGate(value, _context, circuitContext);
SendOutputValue(outputValue, evaluator, evaluationState, circuitContext);
}
public T EvaluateNotGate(T value, GateContext gateContext, CircuitContext circuitContext)
{
return(_innerEvaluator.EvaluateNotGate(value, gateContext, circuitContext));
}
public abstract void ReceiveInputValue <T>(T value, IBatchCircuitEvaluator <T> evaluator, ForwardEvaluationState <T> evaluationState, CircuitContext circuitContext);
public override void ReceiveInputValue <T>(T value, IBatchCircuitEvaluator <T> evaluator, ForwardEvaluationState <T> evaluationState, CircuitContext circuitContext)
{
evaluationState.SetOutput(_outputIndex, value);
}
public ForwardGate EvaluateXorGate(ForwardGate leftInputGate, ForwardGate rightInputGate, GateContext gateContext, CircuitContext circuitContext)
{
ForwardGate gate = new ForwardXorGate(gateContext);
leftInputGate.AddSuccessor(gate);
rightInputGate.AddSuccessor(gate);
return(gate);
}
public ForwardCircuit(IEvaluableCircuit circuit)
{
InputGates = ForwardCircuitBuilder.Build(circuit);
Context = circuit.Context;
}
private StatisticsCircuitEvaluator()
{
_layerStatistics = new List <CircuitLayerStatisticsBuilder>();
_context = null;
}
