public Resistor addResistor(WireGrid pos, WireGrid neg, float val)
{
if (resistors == null) resistors = new ArrayList();
Resistor r = new Resistor(Grid.grid(pos), Grid.grid(neg), val);
resistors.Add(r);
return r;
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Band1,Band2,Band3,Band4,Band5,Use4Bands,Use5Bands,Amount")] Resistor resistor)
{
if (id != resistor.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(resistor);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ResistorExists(resistor.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(resistor));
}
public void AddResistor()
{
var temp = new Resistor(2);
CreatePairForElement(temp);
ContextMenuManager.Instance.ContextMenuActive = false;
}
/// <summary>
/// Получить элемент
/// </summary>
/// <param name="nodeType">Тип узла</param>
/// <param name="name">Имя</param>
/// <param name="value">Номинал</param>
/// <returns>Элемент</returns>
public static ElementBase GetInstance(NodeType nodeType, string name,
double value)
{
ElementBase newElement;
switch (nodeType)
{
case NodeType.Resistor:
newElement = new Resistor(name, value);
break;
case NodeType.Inductor:
newElement = new Inductor(name, value);
break;
case NodeType.Capacitor:
newElement = new Capacitor(name, value);
break;
default:
throw new ArgumentException("Некорректный тип узла.");
}
return(newElement);
}
public void When_BasicParameters_Expect_NoException()
{
// Create the mosfet
var model = new Mosfet1Model("M1");
var parameters =
model.ParameterSets.Get <SpiceSharp.Components.MosfetBehaviors.Level1.ModelBaseParameters>();
// <example_parameters_mos1_creategetter>
// Create a getter for the nominal temperature of the mosfet1 model
var tnomGetter = parameters.CreateGetter <double>("tnom");
double temperature = tnomGetter(); // In degrees Celsius
// </example_parameters_mos1_creategetter>
// <example_parameters_mos1_createsetter>
// Create a setter for the gate-drain overlap capacitance of the mosfet1 model
var cgdoSetter = parameters.CreateSetter <double>("cgdo");
cgdoSetter(1e-15); // 1pF
// </example_parameters_mos1_createsetter>
// <example_parameters_mos1_getparameter>
// Get the parameter that describes the oxide thickness of the mosfet1 model
var toxParameter = parameters.GetParameter <double>("tox");
// </example_parameters_mos1_getparameter>
// <example_parameters_mos1_setparameter>
// Flag the model as a PMOS type
parameters.SetParameter("pmos", true);
// </example_parameters_mos1_setparameter>
// <example_parameters_res_setparameter>
// Set the resistance of the resistor
var res = new Resistor("R1");
res.ParameterSets.SetPrincipalParameter(2.0e3); // 2kOhm
// </example_parameters_res_setparameter>
}
/// <summary>
/// Генерация случайного элемента
/// </summary>
/// <returns></returns>
static public IElement CreateRandomElement()
{
Random rand = new Random();
int n = rand.Next(0, 3);
switch (n)
{
case 0:
{
var r = new Resistor();
r.Value = rand.Next(0, 200);
r.Name = "R";
return(r);
}
case 1:
{
var c = new Capacitor();
c.Value = rand.Next(0, 200);
c.Name = "C";
return(c);
}
case 2:
{
var i = new Inductor();
i.Value = rand.Next(0, 200);
i.Name = "I";
return(i);
}
}
return(null);
}
/// <summary>
/// Тестовая схема №5.
/// </summary>
/// <returns></returns
private IComponent _circuit5()
{
var R1 = new Resistor("R1", 100);
var R2 = new Resistor("R2", 100);
var C1 = new Capacitor("C1", 0.005);
var C2 = new Capacitor("C2", 0.005);
var C3 = new Capacitor("C3", 0.005);
var L1 = new Inductor("L1", 0.5);
var L2 = new Inductor("L2", 0.5);
var circuit1 = new SerialCircuit("circuit1");
var circuit2 = new ParallelCircuit("circuit2");
var circuit3 = new SerialCircuit("circuit3");
var circuit4 = new SerialCircuit("circuit4");
var circuit5 = new ParallelCircuit("circuit5");
circuit5.Circuit.Add(C3);
circuit5.Circuit.Add(R1);
circuit4.Circuit.Add(R2);
circuit4.Circuit.Add(L2);
circuit3.Circuit.Add(L1);
circuit3.Circuit.Add(circuit5);
circuit2.Circuit.Add(C2);
circuit2.Circuit.Add(circuit3);
circuit2.Circuit.Add(circuit4);
circuit1.Circuit.Add(C1);
circuit1.Circuit.Add(circuit2);
return(circuit1);
}
/// <summary>
/// Кнопка рандомного элемента
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void randomelement_Click(object sender, EventArgs e)
{
ICircuit randomCircuit;
var random = new Random();
var elementType = random.Next(3);
if (elementType == 0)
{
randomCircuit = new Resistor()
{
Resistance = random.Next(500)
};
}
else if (elementType == 1)
{
randomCircuit = new Capacitor()
{
Capacitance = random.Next(9000000)
};
}
else
{
randomCircuit = new Induct()
{
Inductance = random.Next(9000000)
};
}
listCircuit.Add(randomCircuit);
var row = _datatable.NewRow();
row[0] = randomCircuit.Name;
row[1] = Convert.ToString(randomCircuit.CalculateValue(Convert.ToDouble(FrequencyTextBox.Text)));
_datatable.Rows.Add(row); //Добавление строки
dataGridView1.Update(); //Обновление таблицы
}
public override void SetSimulationProp(Circuit sim)
{
ResistorComponent = sim.Create <Resistor>();
Connectors[0].DllConnector = ResistorComponent.leadIn;
Connectors[1].DllConnector = ResistorComponent.leadOut;
ResistorComponent.resistance = MinimalResistance;
}
public TristateScanner(double resHigh, double resLow, params double[] resPins)
{
if (resPins == null || resPins.Length == 0)
{
throw new ArgumentNullException("resPins");
}
rValues = new[] { resHigh, resLow }.Concat(resPins).ToArray();
ground = new Node();
outputNode = new Node();
var node5V = new Node();
var source5V = new VoltageSource(5, node5V, ground);
var rPlus = new Resistor(rValues[0], node5V, outputNode);
var rMinus = new Resistor(rValues[1], ground, outputNode);
pins = new KeyValuePair <VoltageSource, Resistor> [rValues.Length - 2];
for (int i = 0; i < pins.Length; i++)
{
var n = new Node();
var s = new VoltageSource(5, n, ground);
var r = new Resistor(rValues[i + 2], n, outputNode);
pins[i] = new KeyValuePair <VoltageSource, Resistor>(s, r);
}
stateCount = 1;
for (int i = 0; i < pins.Length; i++)
{
stateCount *= 3;
}
InitFastNetwork(ground);
}
public void Test3()
{
var head = new Node {
Name = "Head?"
};
var node1 = new Node {
Name = "N1"
};
var refnode = new Node {
IsReferenceNode = true, Name = "Reference"
};
var node2 = new Node {
Name = "N2"
};
var nodes = new List <INode> {
head, node1, refnode, node2
};
var vs = new VoltageSource(12)
{
Name = "Vin", Node1 = head, Node2 = refnode
};
var r1 = new Resistor(100)
{
Name = "R1", Node1 = head, Node2 = refnode
};
var r2 = new Resistor(100)
{
Name = "R2", Node1 = node1, Node2 = refnode
};
var r3 = new Resistor(220)
{
Name = "R3", Node1 = head, Node2 = node2
};
var r4 = new Resistor(1000)
{
Name = "R4", Node1 = node1, Node2 = refnode
};
var sw = new Switch {
IsClosed = true, Name = "LOL I'm a switch", Node1 = node1, Node2 = node2
};
var components = new List <IComponent> {
vs, r1, r2, r3, r4, sw
};
Simulator.AnalyzeAndUpdate(nodes, components);
Assert.Equal(12, head.Voltage, 3);
Assert.Equal(3.509, node1.Voltage, 3);
Assert.Equal(0.159, vs.Current, 3);
Assert.Equal(12, r1.Voltage, 3);
Assert.Equal(0.12, r1.Current, 3);
Assert.Equal(3.509, r2.Voltage, 3);
Assert.Equal(0.035, r2.Current, 3);
Assert.Equal(8.491, r3.Voltage, 3);
Assert.Equal(0.039, r3.Current, 3);
Assert.Equal(3.509, r4.Voltage, 3);
Assert.Equal(0.004, r4.Current, 3);
}
public void CalculateZTest(double frequency)
{
Resistor resistor = new Resistor("R", 20);
Complex expected = new Complex(20, 0);
Assert.AreEqual(expected, resistor.CalculateZ(frequency));
}
Wire oldHookupResistor(Junction source, Junction target, Direction dirToTarget, int resistance)
{
Resistor wire = (Resistor)oldHookup(source, target, dirToTarget, WireType.Resistor);
wire.resistance = resistance;
wire.setSprite(resistance);
return(wire);
}
public void GetImpedanceTest(double resultReal, double resulrImaginary, double angularFrequency, double value)
{
var resistor = new Resistor(value);
var impedance = resistor.GetImpedance(angularFrequency);
Assert.AreEqual(resultReal, impedance.Real);
Assert.AreEqual(resulrImaginary, impedance.Imaginary);
}
public MatSingleResistorNeg(Resistor resistor)
{
if (resistor == null)
{
throw new ArgumentNullException("resistor");
}
this.resistor = resistor;
}
public void TestResistor()
{
IWattCalculator test = new Breadboard();
Assert.AreEqual(3.50, test.Measure());
test = new Resistor(test);
Assert.AreEqual(17.24, test.Measure() - 3.50);
}
public void ThrowsWhenAddingDeviceWithDuplicateName()
{
var elem1 = new Resistor(5, "R1");
var elem2 = new Resistor(5, "R1");
builder.AddDevice(new[] { 1, 2 }, elem1);
Assert.Throws <InvalidOperationException>(() => builder.AddDevice(new[] { 1, 2 }, elem2));
}
public ActionResult CalculateRes(string BandA, string BandB, string BandC, string BandD)
{
Resistor resistor = new Resistor();
double total = resistor.CalculateOhmValue(BandA, BandB, BandC, BandD);
ViewBag.Message = MakeValReadable(total) + " Ohms" + " +/-" + resistor.CalculateTolerance(BandD) + "%";
return(View());
}
public ActionResult Index()
{
Resistor res = new Resistor();
ViewBag.DigitColors = new SelectList(Enum.GetValues(typeof(BandDigitEnum)).Cast <BandDigitEnum>());
ViewBag.MultiplierColors = new SelectList(res.GetBandMultiplierColor());
ViewBag.TolleranceColor = new SelectList(res.GetBandToleranceColor(), "Value", "Key");
return(View(res));
}
public void PlaceElement(ref string line, string type)
{
int id = Int32.Parse(GetSubString(ref line, line.IndexOf(' ')));
int row = Int32.Parse(GetSubString(ref line, line.IndexOf(' ')));
int column = Int32.Parse(GetSubString(ref line, line.IndexOf(' ')));
string direction = GetSubString(ref line, 1);
int node1Id = Int32.Parse(GetSubString(ref line, line.IndexOf(' ')));
int node2Id = Int32.Parse(GetSubString(ref line, line.Length));
Node node1 = gameController.scheme.GetNode(node1Id);
Node node2 = gameController.scheme.GetNode(node2Id);
BaseElement element;
switch (type)
{
case "Re":
element = new Resistor(node1, node2, id);
break;
case "No":
element = new Norator(node1, node2, id);
break;
case "Nu":
element = new Nullator(node1, node2, id);
break;
default:
element = new Conductor(node1, node2, id);
break;
}
gameController.scheme.AddElement(element);
element.GetImage().SetValue(Grid.RowProperty, row);
element.GetImage().SetValue(Grid.ColumnProperty, column);
element.GetImage().SetValue(Panel.ZIndexProperty, 1);
if (direction == "R")
{
element.ChangeImageDirectionToLand();
element.GetImage().SetValue(Grid.RowSpanProperty, 3);
element.GetImage().SetValue(Grid.ColumnSpanProperty, 9);
}
else
{
element.GetImage().SetValue(Grid.RowSpanProperty, 9);
element.GetImage().SetValue(Grid.ColumnSpanProperty, 3);
}
gameController.gameWindow.GameGrid.Children.Add(element.GetImage());
}
public void ShouldRenderDefaultViewOnPostOnInValidModel()
{
var sut = new HomeController();
sut.ModelState.AddModelError("BandAColor", "BandAColor is Requried");
var res = new Resistor();
sut.WithCallTo(p => p.Index(res)).ShouldRenderDefaultView();
}
public void TestKilo()
{
Resistor r = new Resistor();
double expected = 610e3;
double actual = r.CalculateOhmValue("Blue", "Brown", "Yellow", "Gold");
Assert.AreEqual(expected, actual, 0.001, "Resistance value not matched!");
}
public void TestMega()
{
Resistor r = new Resistor();
double expected = 6.1e6;
double actual = r.CalculateOhmValue("Blue", "Brown", "Green", "Gold");
Assert.AreEqual(expected, actual, 0.001, "Resistance value not matched!");
}
public override void SetSimulationProp(Circuit sim)
{
Resistor resistor = sim.Create <Resistor>();
resistor.resistance = _resistorEntity.Resistance;
Connectors[0].DllConnector = resistor.leadIn;
Connectors[1].DllConnector = resistor.leadOut;
}
public void Calculate()
{
var mockResistor = new Moq.Mock <IOhmValueCalculator>();
IOhmValueCalculator resistor = new Resistor();
var result = resistor.CalculateOhmValue("Yellow", "Violet", "Red", "Gold");
Assert.IsNotNull(result);
Assert.AreEqual(result, 4935);
}
public void handler(float value, string source, string target)
{
Component sourceComponent = GameObject.Find(source).GetComponent <Component>();
Component targetComponent = GameObject.Find(target).GetComponent <Component>();
ComponentBase srcData = sourceComponent.getComponentData();
ComponentBase data = targetComponent.getComponentData();
if (target.Contains("resistor"))
{
data.changed.Add("set", "R");
data.changed.Add("id", data.id);
data.changed.Add("val", (int)value);
data.value = (int)value;
jsonHandler.updateJsonEvent.Invoke(data);
Resistor resistor = (Resistor)data;
int convertedValue = resistor.minValue + (int)value * resistor.stepResistance;
Util.getChildObject(target, "ValueText").GetComponent <Text>().text = Util.changeUnit(convertedValue, "resistor");
}
else if (target.Contains("capacitor"))
{
if ((GameObject.Find("FrequencyConstraintsValue").activeSelf) && (GameObject.Find("SliderValuePanelTitle").GetComponent <Text>().text == source))
{
Resistor resistor = (Resistor)srcData;
int convertedValue = resistor.minValue + (int)value * resistor.stepResistance;
//Debug.Log(Util.getChildObject(target, "ValueText").GetComponent<Text>().text);
string targetValueText = Util.getChildObject(target, "ValueText").GetComponent <Text>().text;
double targetValue = double.Parse(targetValueText.Substring(0, targetValueText.Length - 2));
if (targetValueText.EndsWith("p"))
{
targetValue *= 0.000000000001;
}
else if (targetValueText.EndsWith("n"))
{
targetValue *= 0.000000001;
}
else if (targetValueText.EndsWith("u"))
{
targetValue *= 0.000001;
}
float RCFomulaResult = RCFormula(convertedValue, targetValue);
Text FrequencyConstraintsValue = GameObject.Find("FrequencyConstraintsValue").GetComponent <Text>();
if (RCFomulaResult == -1)
{
FrequencyConstraintsValue.text = "infinity";
}
else
{
FrequencyConstraintsValue.text = Util.changeUnit(RCFormula(convertedValue, targetValue) * 1000, "frequency");
}
//GameObject.Find("FrequencyConstraintsValue").GetComponent<Text>().text = Util.changeUnit(RCFormula(convertedValue, targetValue)*1000, "frequency");
}
}
}
public async Task <IActionResult> Create([Bind("Id,Band1,Band2,Band3,Band4,Band5,Use4Bands,Use5Bands,Amount")] Resistor resistor)
{
if (ModelState.IsValid)
{
_context.Add(resistor);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(resistor));
}
public void TestResistorFromFactoryMethod()
{
Resistor resistor = ResistorFactory.fourBands();
((Band)resistor.Bands[0]).Color = ResistorColor.Green;
((Band)resistor.Bands[1]).Color = ResistorColor.Black;
((MultiplierBand)resistor.Bands[2]).Color = ResistorMultiplier.Black;
((ToleranceBand)resistor.Bands[3]).Color = ResistorTolerance.Gold;
Assert.AreEqual(50, resistor.Value);
}
public void Test5()
{
var head = new Node {
Name = "Head"
};
var node1 = new Node {
Name = "N1"
};
var refnode = new Node {
IsReferenceNode = true, Name = "Ref"
};
var nodes = new List <INode> {
head, node1, refnode
};
var vs = new VoltageSource(12)
{
Node1 = head, Node2 = refnode, Name = "Vin1"
};
var r1 = new Resistor(100)
{
Node1 = head, Node2 = refnode, Name = "R1"
};
var r2 = new Resistor {
Current = 0.035087719298245612, Node1 = node1, Node2 = refnode, Name = "R2"
};
var r3 = new Resistor(220)
{
Node1 = head, Node2 = node1, Name = "R3"
};
var r4 = new Resistor(1000)
{
Node1 = node1, Node2 = refnode, Name = "R4"
};
var components = new List <IComponent> {
vs, r1, r2, r3, r4
};
Simulator.AnalyzeAndUpdate(nodes, components);
Assert.Equal(100, r2.Resistance, 0);
Assert.Equal(12, head.Voltage, 3);
Assert.Equal(3.509, node1.Voltage, 3);
Assert.Equal(0.159, vs.Current, 3);
Assert.Equal(12, r1.Voltage, 3);
Assert.Equal(0.12, r1.Current, 3);
Assert.Equal(3.509, r2.Voltage, 3);
//Assert.Equal(0.035, r2.Current, 3);
Assert.Equal(8.491, r3.Voltage, 3);
Assert.Equal(0.039, r3.Current, 3);
Assert.Equal(3.509, r4.Voltage, 3);
Assert.Equal(0.004, r4.Current, 3);
}
public void ShouldRenderDefaultViewOnPost()
{
var sut = new HomeController();
var res = new Resistor();
res.BandAColor = "Brown";
res.BandBColor = "green";
res.BandCColor = "Silver";
res.BandDColor = "Violet";
sut.WithCallTo(p => p.Index(res)).ShouldRenderDefaultView();
}
public void TestResistorGetValueMethod()
{
Resistor resistor = makeFourBandResistor();
((Band)resistor.Bands[0]).Color = ResistorColor.Orange;
((Band)resistor.Bands[1]).Color = ResistorColor.Red;
((MultiplierBand)resistor.Bands[2]).Color = ResistorMultiplier.Brown;
((ToleranceBand)resistor.Bands[3]).Color = ResistorTolerance.Gold;
Assert.AreEqual(320, resistor.Value);
}
internal static Resistor CombineInSeries(Resistor r1, Resistor r2)
{
r1.RemoveFromGrid();
r2.RemoveFromGrid();
Resistor r = new Resistor(r1, r2, false);
r.AddToGrid();
return r;
}
internal Resistor(Resistor r1, Resistor r2, bool parallel)
{
MonoBehaviour.print(r1.Val + " + " + r2.Val);
component1 = r1;
component2 = r2;
r1.parent = r2.parent = this;
this.parallel = parallel;
if (parallel)
{
if (r1.Val == r2.Val) Val = r1.Val / 2;
else //Takes care of the values being zero.
Val = r1.Val * r2.Val / (r1.Val + r2.Val);
}
else Val = r1.Val + r2.Val;
if (parallel)
{
Pos = r1.Pos;
Neg = r1.Neg;
}
else
{
if (r1.Pos == r2.Neg) { Pos = r2.Pos; Neg = r1.Neg; }
if (r1.Pos == r2.Pos) { Pos = r1.Neg; Neg = r2.Neg; }
if (r1.Neg == r2.Pos) { Pos = r1.Pos; Neg = r2.Neg; }
if (r1.Neg == r2.Neg) { Pos = r1.Pos; Neg = r2.Pos; }
}
}
public void AddResistor()
{
var temp = new Resistor(2);
CreatePairForElement(temp);
ContextMenuManager.Instance.ContextMenuActive = false;
}
float GetCurrentForComponent(Resistor comp)
{
if (!parallel) return GetCurrent();
else
{
Resistor otherComponent;
if (component1 == comp) otherComponent = component2; else otherComponent = component1;
return (GetCurrent() * otherComponent.Val / (component1.Val + component2.Val));
}
}
internal static bool inSeries(Resistor r1, Resistor r2)
{
//MonoBehaviour.print("Series 0");
if (!r1.addedToGrid || !r2.addedToGrid) return false;
if (r1.Pos == null || r1.Neg == null || r2.Pos == null || r2.Neg == null) return false;
//MonoBehaviour.print("Series 1");
if (r1.Pos != r2.Pos && r1.Pos != r2.Neg)
{
// MonoBehaviour.print("Series 1_2");
if (r1.Neg == r2.Pos || r1.Neg == r2.Neg)
{
// MonoBehaviour.print("Series 1_3");
// MonoBehaviour.print(r1.Neg.nComponents);
if (r1.Neg.nComponents == 2)
{
// MonoBehaviour.print("Series 1_4");
return true;
}
}
}
if (r1.Neg != r2.Pos && r1.Neg != r2.Neg)
{
//MonoBehaviour.print("Series 2_2");
if (r1.Pos == r2.Pos || r1.Pos == r2.Neg)
{
// MonoBehaviour.print("Series 2_3");
//MonoBehaviour.print(r1.Pos.nComponents);
if (r1.Pos.nComponents == 2)
{
// MonoBehaviour.print("Series 2_4");
return true;
}
}
}
return false;
}
internal static bool inSelfLoop(Resistor r1)
{
if (r1.Pos == null || r1.Neg == null) return false;
return r1.Pos == r1.Neg;
}
internal static bool inParallel(Resistor r1, Resistor r2)
{
if (!r1.addedToGrid || !r2.addedToGrid) return false;
if (r1.Pos == null || r1.Neg == null || r2.Pos == null || r2.Neg == null) return false;
if (r1.Pos == r2.Pos && r1.Neg == r2.Neg) return true;
return (r1.Pos == r2.Neg && r1.Neg == r2.Pos);
}
internal static Resistor CombineInParallel(Resistor r1, Resistor r2)
{
r1.RemoveFromGrid();
r2.RemoveFromGrid();
Resistor r = new Resistor(r1, r2, true);
r.AddToGrid();
return r;
}
