/// <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 }); }