/// <summary>Processes given set of statements.</summary>
protected override void DoProcess()
{
var name = DeviceName;
var nodes = GetNodeIds(1, 2);
if (RawStatement.Length < 4)
{
return; // nothing more to do here
}
ICircuitDefinitionDevice device;
if (char.IsDigit(RawStatement[3].Value[0]) || RawStatement[3].Value[0] == '-' || RawStatement[3].Value[0] == '+'
) // constant source
{
var val = GetValue(3);
device = GetDevice(new ConstantBehavior {
Value = val
}, name);
}
else // tran function
{
var paramTokens = Utils.Parser.Retokenize(RawStatement, 3).ToList();
device = GetDevice(GetBehaviorParam(paramTokens), name);
}
if (Errors == 0)
{
CircuitBuilder.AddDevice(nodes, device);
}
}
public static (bool success, Circuit circuit, string error) GetFromFile(string filePath)
{
CircuitParser parser = CircuitParser.GetParser();
(bool success, string fileName, string error)result = parser.AddFile(filePath);
if (result.success)
{
string fileName = result.fileName;
CircuitBuilder circuitBuilder = new CircuitBuilder();
circuitBuilder.SetName(fileName);
foreach (var nodeString in parser.GetNodeString(fileName))
{
circuitBuilder.AddNode(nodeString.name, nodeString.type);
}
foreach (var connectionString in parser.GetConnectionString(fileName))
{
foreach (string outputNode in connectionString.outputs)
{
circuitBuilder.AddConnection(connectionString.input, outputNode);
}
}
circuits[fileName] = circuitBuilder.GetCircuit();
return(true, circuits[fileName], "");
}
else
{
return(false, null, result.error);
}
}
private void SelectCircuit()
{
_circuit = CircuitBuilder.CreateCircuit(SelectedCircuit);
if (_circuit == null)
{
ConsoleOutput.Add("Circuit is not valid.");
return;
}
SourceNodes.Clear();
foreach (Source source in _circuit.GetSourceNodes())
{
SourceNodes.Add(source);
}
Nodes.Clear();
foreach (Node node in _circuit.GetNodes())
{
Nodes.Add(node);
}
ProbeNodes.Clear();
foreach (Node node in _nodes.Where(n => n.TypeName == "PROBE").ToList())
{
ProbeNodes.Add(node);
}
}
private static void Output(CircuitBuilder builder, SecurePrimitive primitive)
{
foreach (Wire wire in primitive.Wires)
{
builder.Output(wire);
}
}
public static void ResistorSweep()
{
var builder = new CircuitBuilder();
builder
.AddVoltageSource(1, 0, 12, "VS")
.AddResistor(0, 2, 10)
.AddResistor(1, 2, 10)
.AddResistor(2, 3, 5)
.AddResistor(1, 3, 5, "R1");
var circuit = builder.BuildCircuit();
var model = circuit.GetLargeSignalModel();
var vsouce = (ITwoTerminalLargeSignalDevice)model.FindDevice("VS");
var res = (Resistor)circuit.FindDevice("R1");
// sweep for values from 1 Ohm to 15 Ohm
for (var i = 1; i <= 15; i++)
{
res.Resistance = i + 1; // set resistance
// calculate
model.EstablishDcBias();
var v1 = model.NodeVoltages[1];
var v2 = model.NodeVoltages[2];
var v3 = model.NodeVoltages[3];
var iV = vsouce.Current;
// print values
Console.WriteLine($"{i + 1}Ohm: {v1}V {v2}V {v3}V {iV}A");
}
}
private static void RunSecureComputationParty(int startPort, int numberOfParties, int localPartyId, BitArray localInput, BitArray expectedOutput)
{
using (IMultiPartyNetworkSession session = TestNetworkSession.EstablishMultiParty(localPartyId, numberOfParties))
{
using (CryptoContext cryptoContext = CryptoContext.CreateDefault())
{
IObliviousTransfer obliviousTransfer = new NaorPinkasObliviousTransfer(
new SecurityParameters(47, 23, 4, 1, 1),
cryptoContext
);
IMultiplicativeSharing multiplicativeSharing = new ObliviousTransferMultiplicativeSharing(
obliviousTransfer,
cryptoContext
);
GMWSecureComputation computation = new GMWSecureComputation(session, multiplicativeSharing, cryptoContext);
SetIntersectionCircuitRecorder circuitRecorder = new SetIntersectionCircuitRecorder(numberOfParties, localInput.Length);
CircuitBuilder circuitBuilder = new CircuitBuilder();
circuitRecorder.Record(circuitBuilder);
ForwardCircuit circuit = new ForwardCircuit(circuitBuilder.CreateCircuit());
BitArray output = computation.EvaluateAsync(circuit, circuitRecorder.InputMapping, circuitRecorder.OutputMapping, localInput).Result;
CollectionAssert.AreEqual(
expectedOutput,
output,
"Incorrect output {0} (should be {1}).",
output.ToBinaryString(),
expectedOutput.ToBinaryString()
);
}
}
}
public void ThrowsWhenNoModelCreatorExists()
{
var circuitDef = new CircuitBuilder().AddDevice(new[] { 0, 1 }, new TestDeviceDefinition())
.AddDevice(new[] { 1, 0 }, new TestDeviceDefinition()).BuildCircuit();
Assert.Throws <InvalidOperationException>(() => creator.Create <LargeSignalCircuitModel>(circuitDef));
}
private static IEnumerable <Wire> InputWires(CircuitBuilder builder, int numberOfWires)
{
for (int i = 0; i < numberOfWires; ++i)
{
yield return(builder.Input());
}
}
private static void OutputWires(CircuitBuilder builder, IEnumerable <Wire> wires)
{
foreach (Wire wire in wires)
{
builder.Output(wire);
}
}
private void Output(CircuitBuilder builder, SecureWord word)
{
foreach (Wire wire in word.Wires)
{
builder.Output(wire);
}
}
private void Construct(CircuitBuilder builder)
{
builder.BuildInputNodes();
builder.BuildOutputNodes();
builder.BuildGridNodes();
builder.BuildEdges();
}
public void Initialize()
{
// Arrange
_circuitBuilder = new CircuitBuilder();
_nodeDefinitions = new List <NodeDefinition>()
{
new NodeDefinition()
{
Name = "A",
Type = "INPUT_HIGH",
Outputs = { "NODE1" }
},
new NodeDefinition()
{
Name = "B",
Type = "INPUT_HIGH",
Outputs = { "NODE1" }
},
new NodeDefinition()
{
Name = "NODE1",
Type = "AND",
Inputs = { "A", "B" },
Outputs = { "Cout" }
}
,
new NodeDefinition()
{
Name = "Cout",
Type = "PROBE",
Inputs = { "NODE1" }
}
};
}
/// <summary>Adds a resistor between specified nodes.</summary>
/// <param name="builder">The builder.</param>
/// <param name="nodes">Array of connections of the subcircuit.</param>
/// <param name="subcircuit">Resistance of the resistor in ohms.</param>
/// <param name="tag">Tag to identify the device.</param>
/// <returns></returns>
public static CircuitBuilder AddSubcircuit(this CircuitBuilder builder, int[] nodes,
ISubcircuitDefinition subcircuit,
object tag = null)
{
builder.AddDevice(nodes, new Subcircuit(subcircuit, tag));
return(builder);
}
public void TestInductorAsShortCircuit()
{
LargeSignalCircuitModel model;
Console.WriteLine("With inductor:");
{
var circuit = new CircuitBuilder()
.AddVoltageSource(1, 0, 5)
.AddResistor(1, 0, 2)
.AddResistor(2, 0, 5)
.AddInductor(1, 2, 1).BuildCircuit();
model = creator.Create <LargeSignalCircuitModel>(circuit);
}
model.EstablishDcBias();
Output.PrintCircuitStats(model);
var withInductorVoltages = model.NodeVoltages.ToArray();
Console.WriteLine("\nWithout inductor:");
{
var circuit = new CircuitBuilder()
.AddVoltageSource(1, 0, 5)
.AddResistor(1, 0, 2)
.AddResistor(1, 0, 5).BuildCircuit();
model = creator.Create <LargeSignalCircuitModel>(circuit);
}
model.EstablishDcBias();
Output.PrintCircuitStats(model);
var withoutInductorVoltages = model.NodeVoltages.ToList();
withoutInductorVoltages.Insert(1, withoutInductorVoltages[1]);
Assert.Equal(withoutInductorVoltages, withInductorVoltages, new DoubleComparer(1e-10));
}
public void TestCapacitorAsOpenCircuit()
{
LargeSignalCircuitModel model;
Console.WriteLine("With capacitor:");
{
var circuit = new CircuitBuilder()
.AddVoltageSource(1, 0, 5)
.AddResistor(1, 0, 2)
.AddResistor(2, 0, 5)
.AddCapacitor(1, 2, 1).BuildCircuit();
Assert.Equal(3, circuit.NodeCount);
model = creator.Create <LargeSignalCircuitModel>(circuit);
}
model.EstablishDcBias();
Output.PrintCircuitStats(model);
var withCapacitorVoltages = model.NodeVoltages.ToArray();
Console.WriteLine("\nWithout capacitor:");
{
var circuit = new CircuitBuilder()
.AddVoltageSource(1, 0, 5)
.AddResistor(1, 0, 2)
.AddResistor(2, 0, 5).BuildCircuit();
model = creator.Create <LargeSignalCircuitModel>(circuit);
}
model.EstablishDcBias();
Output.PrintCircuitStats(model);
var withoutCapacitorVoltages = model.NodeVoltages.ToArray();
Assert.Equal(withoutCapacitorVoltages, withCapacitorVoltages);
}
private static void OutputPrimitives(CircuitBuilder builder, SecurePrimitive[] primitives)
{
for (int i = 0; i < primitives.Length; ++i)
{
OutputWires(builder, primitives[i].Wires);
}
}
private static void OutputPrimitives(CircuitBuilder builder, SecurePrimitive[] primitives)
{
foreach (SecurePrimitive primitive in primitives)
{
OutputWires(builder, primitive.Wires);
}
}
public void ConnectNonExistentNodes_Negative()
{
TestHelper.SetTestPaths();
CircuitBuilder circuitBuilder = new CircuitBuilder();
Assert.ThrowsException <System.InvalidOperationException>(() => circuitBuilder.AddConnection("NODE1", "NODE2"));
}
public void FinishWithoutName_Negative()
{
TestHelper.SetTestPaths();
CircuitBuilder circuitBuilder = new CircuitBuilder();
Assert.ThrowsException <System.InvalidOperationException>(() => circuitBuilder.GetCircuit());
}
private void BuildCircuit()
{
CircuitBuilder circuitBuilder = new CircuitBuilder();
Construct(circuitBuilder);
_circuit = circuitBuilder.GetResult();
ValidateCircuit();
}
/// <summary>Adds a diode between specified nodes.</summary>
/// <param name="builder">The builder.</param>
/// <param name="n1">Positive node of the device.</param>
/// <param name="n2">Negative node of the device.</param>
/// <param name="config">Function for configuring device model parameters.</param>
/// <param name="tag">Tag to identify the device.</param>
/// <returns></returns>
public static CircuitBuilder AddDiode(this CircuitBuilder builder, int n1, int n2,
Action <DiodeParams> config, object tag = null)
{
var param = DiodeParams.Default;
config(param);
builder.AddDevice(new[] { n1, n2 }, new Diode(param, tag));
return(builder);
}
/// <summary>Adds a diode between specified nodes.</summary>
/// <param name="builder">The builder.</param>
/// <param name="nCollector">Collector node of the device.</param>
/// <param name="nBase">Base node of the device.</param>
/// <param name="nEmitter">Emitter node of the device.</param>
/// <param name="config">Function for configuring device model parameters.</param>
/// <param name="tag">Tag to identify the device.</param>
/// <returns></returns>
public static CircuitBuilder AddBjt(this CircuitBuilder builder, int nCollector, int nBase, int nEmitter,
Action <BjtParams> config, object tag = null)
{
var param = BjtParams.Default;
config(param);
builder.AddDevice(new[] { nCollector, nBase, nEmitter, 0 }, new Bjt(param, tag));
return(builder);
}
private static SecureWord Input(CircuitBuilder builder, int numberOfBits)
{
Wire[] wires = new Wire[numberOfBits];
for (int i = 0; i < numberOfBits; ++i)
{
wires[i] = builder.Input();
}
return(new SecureWord(builder, wires));
}
public async Task TestMethod6()
{
var builder = new CircuitBuilder()
.AddInMemorySource(@"# Hallo There
In1: INPUT_HIGH;
In2: INPUT_LOW;
Out1: PROBE;" )
.AddDefaultNodes();
var c = await builder.Build();
}
public CircuitViewModel()
{
_fileStrategyFactory = FileStrategyFactory.Instance;
_circuitBuilder = new CircuitBuilder();
OpenCircuitCommand = new RelayCommand(OpenCircuit);
ResetCircuitCommand = new RelayCommand(ResetCircuit);
QuitCommand = new RelayCommand(Quit);
ClearLogsCommand = new RelayCommand(ClearLogs);
Logger = Logger.Instance;
_validator = new Validator();
}
public ParsingScope(Token[] subcktStatement, ParsingScope parent = null)
{
SubcktStatement = subcktStatement;
ParentScope = parent;
CircuitBuilder = new CircuitBuilder();
Statements = new List <DeferredStatement>();
SymbolTable = new SymbolTable(parent?.SymbolTable);
Errors = new List <SpiceParserError>();
OtherStatements = new List <SpiceStatement>();
Depth = parent?.Depth + 1 ?? 0;
}
/// <summary>Processes given set of statements.</summary>
protected override void DoProcess()
{
var name = DeviceName;
var nodes = GetNodeIds(1, 2);
var rvalue = GetValue(3);
if (Errors == 0)
{
CircuitBuilder.AddDevice(nodes, new Resistor(rvalue, name));
}
}
/// <summary>Processes given set of statements.</summary>
protected override void DoProcess()
{
var name = DeviceName;
var nodes = GetNodeIds(1, 4);
var gain = GetValue(5);
if (Errors == 0)
{
CircuitBuilder.AddDevice(nodes, new Vccs(gain, name));
}
}
private static SecurePrimitive[] InputPrimitives(CircuitBuilder builder, InputPrimitiveDeclaration[] inputDeclaration)
{
SecurePrimitive[] primitives = new SecurePrimitive[inputDeclaration.Length];
for (int i = 0; i < primitives.Length; ++i)
{
PrimitiveConverter converter = inputDeclaration[i].Converter;
primitives[i] = converter.FromWires(builder, InputWires(builder, converter.NumberOfWires));
}
return(primitives);
}
protected override SecurePrimitive[] Run(CircuitBuilder builder, SecurePrimitive[] inputs)
{
SecureWord[] inputWords = inputs.Cast <SecureWord>().ToArray();
SecureSetIntersection setIntersection = new SecureSetIntersection(inputWords, _numberOfCounterBits);
return(new[]
{
setIntersection.Intersection,
setIntersection.Counter
});
}
