public void GenerateDatas()
{
try
{
Collection.Clear();
Circuit cir = new Circuit();
cir.ReadCircuit("Circuits/RCcharge.net");
Circuit cir2 = (Circuit)cir.Clone();
cir2.Setup.RemoveAt(0);
ACAnalysis ac = new ACAnalysis();
cir2.Setup.Add(ac);
ACSweepSolver.Optimize(cir2);
cir2.Solve();
ACSweepSolver sol = (ACSweepSolver)ac.Solver;
foreach (var res in sol.Voltages)
{
//Console.Write(res.Key.ToString() + "rad/seg");
foreach (var nodo in res.Value)
{
if (nodo.Key == "$N_0001")
//Console.Write(nodo.Key + " " + nodo.Value.ToString() + "V\r\n");
this.Collection.Add(new Point(res.Key, nodo.Value.Real));
}
}
}
catch (Exception ex)
{
throw;
}
}
public void Simulate(string circuitname)
{
TxtStatus.Text = circuitname;
cir = new Circuit();
//cir.ReadCircuit("Circuits/RCL.net");
cir.ReadCircuit(circuitname);
cir2 = (Circuit)cir.Clone();
cir2.Setup.RemoveAt(0);
ACAnalysis ac = new ACAnalysis();
cir2.Setup.Add(ac);
ACSweepSolver.Optimize(cir2);
Refresh();
}
private void Button_Click(object sender, RoutedEventArgs e)
{
model = new ComplexPlainViewModel();
model.ColorCoding = ColorCoding.ByLights;
Circuit cir = new Circuit();
cir.ReadCircuit("Circuits/RCL.net");
cir2 = (Circuit)cir.Clone();
cir2.Setup.RemoveAt(0);
ComplexPlainAnalysis ac1 = new ComplexPlainAnalysis();
cir2.Setup.Add(ac1);
ACSweepSolver.Optimize(cir2);
cir2.Solve();
sol1 = (ComplexPlainSolver)ac1.Solver;
int scalefactor = 5000;
model.MinX = ac1.SigmaMin / scalefactor;
model.MaxX = ac1.SigmaMax / scalefactor;
model.MaxY = ac1.WMax / scalefactor;
model.MinY = ac1.WMin / scalefactor;
model.Columns = ac1.Points;
model.Rows = ac1.Points;
var data = new Point3D[model.Rows, model.Columns];
//public Tuple<Complex32, Complex32>[,] Results { get; set; }
MathNet.Numerics.Complex32 W;
for (int i = 0; i < model.Rows; i++)
for (int j = 0; j < model.Columns; j++)
{
W = sol1.WfromIndexes[new Tuple<int, int>(i, j)];
foreach (var node in sol1.Voltages[W])
{
if (node.Key == "out")
data[i, j] = new Point3D(W.Real /scalefactor,
W.Imaginary /scalefactor,
//node.Value.Magnitude);
2 * Math.Log10(node.Value.Magnitude));
}
}
model.Data = data;
model.UpdateModel(false);
//model.CreateDataArray(ModuleInDB);
DataContext = model;
}
public void Simulate(string circuitname)
{
propgrid.SelectedObject = null;
cir = new Circuit();
cir.ReadCircuit(circuitname);
cir2 = (Circuit)cir.Clone();
cir2.Setup.RemoveAt(0);
if (ac5 == null || cir2.Setup.Count == 0)
{
ac5 = new TransientAnalysis();
ac5.Step = "50n";
ac5.FinalTime = "50u";
cir2.Setup.Add(ac5);
}
TransientSolver sol5 = (TransientSolver)ac5.Solver;
TransientSolver.Optimize(cir2);
Refresh();
lbComponents.ItemsSource = cir.Components;
lbNodes.ItemsSource = cir.Nodes.Values;
}
private void LoadField()
{
Circuit cir = new Circuit();
cir.ReadCircuit("Circuits/RCL.net");
cir2 = (Circuit)cir.Clone();
cir2.Setup.RemoveAt(0);
ComplexPlainAnalysis ac1 = new ComplexPlainAnalysis();
cir2.Setup.Add(ac1);
ACSweepSolver.Optimize(cir2);
cir2.Solve();
sol1 = (ComplexPlainSolver)ac1.Solver;
int Rows = ac1.Points;
int Columns = ac1.Points;
double[,] data = new double[Rows, Columns];
Point[,] gridData = new Point[Rows, Columns];
MathNet.Numerics.Complex32 W;
for (int i = 0; i < Rows; i++)
for (int j = 0; j < Columns; j++)
{
W = sol1.WfromIndexes[new Tuple<int, int>(i, j)];
foreach (var node in sol1.Voltages[W])
{
if (node.Key == "out")
{
data[i, j] = 20 * Math.Log10(node.Value.Magnitude);
//data[i, j] = 180 * node.Value.Phase / Math.PI;
gridData[i, j] = new Point(W.Real, W.Imaginary);
}
}
}
WarpedDataSource2D<double> dataSource = new WarpedDataSource2D<double>(data, gridData);
isolineGraph.DataSource = dataSource;
trackingGraph.DataSource = dataSource;
}
public object Clone()
{
Circuit cir = new Circuit();
foreach (var node in Nodes)
{
cir.Nodes.Add(node.Key, node.Value);
}
cir.Components.AddRange(Components);
foreach (var comp in cir.Components)
{
comp.OwnerCircuit = cir;
}
cir.Reference = Reference;
cir.OriginalCircuit = this;
return cir;
}
private void PreAnalizeToSolve(Circuit cir, List<Node> nodos, SolveInfo solveinfo)
{
nodos.AddRange(cir.Nodes.Values);
nodos.Remove(cir.Reference);
//guardo para futuro los nodos de los componentes especiales
if (cir.OriginalCircuit != null)
{
foreach (var comp in cir.OriginalCircuit.Components)
{
if (comp is ControlledDipole)
{
foreach (var nodo in comp.Nodes)
{
if (!nodo.IsReference)
{
SpecialComponentInfo info = new SpecialComponentInfo(comp);
info.ImportantOutputNodes.Add(nodo);
solveinfo.specialcomponents.Add(info);
if (!solveinfo.nortonnodes.Contains(nodo))
solveinfo.nortonnodes.Add(nodo);
//especialcomponents.Add(nodo, comp);
}
}
}
}
}
foreach (var compo in cir.Components)
{
if (compo is Branch)
solveinfo.ramas.Add((Branch)compo);
}
foreach (var nodo in nodos)
{
//los nodos de salida de un dispositivo VcV deben resolverse mediante matrices
if (solveinfo.nortonnodes.Contains(nodo))
continue;
if (nodo.TypeOfNode == Node.NodeType.MultibranchCurrentNode ||
nodo.TypeOfNode == Node.NodeType.VoltageLinkedNode
)
solveinfo.nortonnodes.Add(nodo);
else if (nodo.TypeOfNode == Node.NodeType.VoltageDivideNode ||
nodo.TypeOfNode == Node.NodeType.VoltageFixedNode)
{
solveinfo.calculablenodes.Add(nodo);
}
}
}
public bool Solve(Components.Circuit cir, BasicAnalysis ana)
{
List<Node> nodos = new List<Node>();
Voltages = new Dictionary<double, Dictionary<string, double>>();
Currents = new Dictionary<double, Dictionary<string, double>>();
circuit = cir;
SolveInfo solveinfo = new SolveInfo();
//nodos.AddRange(cir.Nodes.Values);
//nodos.Remove(cir.Reference);
PreAnalizeToSolve(cir, nodos, solveinfo);
TransientAnalysis analis = ana as TransientAnalysis;
double t, tf, deltat;
deltat = StringUtils.DecodeString(analis.Step);
tf = StringUtils.DecodeString(analis.FinalTime);
t = 0;
cir.CircuitTime = t;
cir.Reset();
while (t < tf)
{
//Calculo de tensiones de nodos
Calculate(solveinfo, t);
Dictionary<string, double> result = new Dictionary<string, double>();
#region almacenamiento temporal
foreach (var nodo in nodos)
{
result.Add(nodo.Name, nodo.Voltage.Real);
}
if (!Voltages.ContainsKey(t))
Voltages.Add(t, result);
#endregion
//calculo las corrientes:
CalculateCurrents(cir, t);
Dictionary<string, double> currents = new Dictionary<string, double>();
StorageCurrents(cir, currents);
Currents.Add(t, currents);
cir.CircuitTime = t;
t += deltat;
}
cir.State = Circuit.CircuitState.Solved;
return true;
}
public static bool Optimize(Circuit cir)
{
List<Dipole> yaanalizados = new List<Dipole>();
List<ParallelBlock> paralelos = new List<ParallelBlock>();
List<Node> nodosnormales = new List<Node>();
List<Branch> ramas = new List<Branch>();
ParallelBlock para = null;
#region Chequeo de nodos sueltos o componentes colgantes
foreach (var nodo in cir.Nodes.Values)
{
if (nodo.Components.Count == 0)
{
throw new NotImplementedException();
}
//componente con borne suelto
//if (nodo.Components.Count == 1)
//{
// throw new NotImplementedException();
//}
}
#endregion
#region busco componentes en paralelo
if (false)
//no se hace un paralelo si solo hay 2 componentes
if (cir.Components.Count > 2)
{
for (int i = 0; i < cir.Components.Count - 1; i++)
{
if (yaanalizados.Contains(cir.Components[i]))
continue;
Dipole comp1 = cir.Components[i];
for (int j = i + 1; j < cir.Components.Count; j++)
{
if (yaanalizados.Contains(cir.Components[j]))
continue;
Dipole comp2 = cir.Components[j];
//comparten 2 nodos
if ((comp1.Nodes[0] == comp2.Nodes[0] && comp1.Nodes[1] == comp2.Nodes[1]) ||
(comp1.Nodes[0] == comp2.Nodes[1] && comp1.Nodes[1] == comp2.Nodes[0]))
{
if (para == null)
{
para = new ParallelBlock(cir, comp1, comp2);
paralelos.Add(para);
yaanalizados.Add(comp1);
yaanalizados.Add(comp2);
}
else
{
para.Components.Add(comp2);
yaanalizados.Add(comp2);
}
}
}
}
}
#endregion
#region reemplazo los componentes paralelos separados por
//el correspondiente block paralelo
foreach (var para1 in paralelos)
{
foreach (var compo in para1.Components)
cir.Components.Remove(compo);
cir.Components.Add(para1);
}
#endregion
#region identifico la tierra
Node tierra = cir.Reference;
if (tierra == null)
foreach (var item in cir.Nodes.Values)
{
if (item.IsReference)
{
tierra = item;
cir.Reference = tierra;
break;
}
}
#endregion
#region arranco desde tierra he identifico los nodos de tension fija,
//posibles nodos flotantes de corriente y ramas conectadas a tierra
List<Dipole> componenttoearh = new List<Dipole>();
componenttoearh.AddRange(tierra.Components);
foreach (var compo in componenttoearh)
{
//los nodos de tension fija
if (compo is VoltageGenerator || compo is Capacitor)
{
Node other = compo.OtherNode(tierra);
other.TypeOfNode = Node.NodeType.VoltageFixedNode;
other.Voltage = compo.Voltage;
}
//if (compo is Capacitor)
//{
// Node other = compo.OtherNode(tierra);
// other.TypeOfNode = Node.NodeType.VoltageVariableNode;
// other.Voltage = compo.Voltage;
//}
foreach (var rama in ramas)
{
if (rama.Components.Contains(compo))
goto end;
}
//desde tierra los nodos son:
//a: pertenecen a una rama. hay que levantar dicha rama...
//b: son nodos normales flotantes (se aplica teorema de nodo)
Branch br = FindBranch(cir, tierra, compo);
//si no forma parte de una rama, la rama de 1 elemento se desecha
ValidateBranch(yaanalizados, nodosnormales, ramas, tierra, compo, br);
end: ;
}
#endregion
#region Analizo las ramas faltantes desde los nodos normales encontrados
foreach (var nodo in nodosnormales)
{
foreach (var compo in nodo.Components)
{
if (ramas.Contains(compo) || yaanalizados.Contains(compo))
continue;
Branch br = FindBranch(cir, nodo, compo);
ValidateBranch(yaanalizados, nodosnormales, ramas, nodo, compo, br);
}
}
#endregion
//reemplazo los componentes que arman una rama por la propia rama
foreach (var rama in ramas)
foreach (var compo in rama.Components)
cir.Components.Remove(compo);
cir.Components.AddRange(ramas);
cir.State = Circuit.CircuitState.Optimized;
return true;
}
protected static Branch FindBranch(Circuit cir, Node initialNode, Dipole Component)
{
Branch br = new Branch(cir);
Dipole compo = Component;
Node nodo = Component.OtherNode(initialNode);
br.Nodes.Clear();
//solo es valido si el circuito fue optimizado, y los paralelos
//se reemplazaron por bloques paralelo
while (nodo.Components.Count == 2 && cir.Reference != nodo)
{
br.Components.Add(compo);
br.InternalNodes.Add(nodo);
compo = nodo.OtherComponent(compo);
nodo = compo.OtherNode(nodo);
}
br.Components.Add(compo);
if (br.Components.Count > 1)
{
initialNode.Components.Remove(Component);
initialNode.Components.Add(br);
nodo.Components.Remove(compo);
nodo.Components.Add(br);
nodo.TypeOfNode = Node.NodeType.MultibranchCurrentNode;
}
br.Nodes.Add(initialNode);
br.Nodes.Add(nodo);
//hay que recorrer la rama para buscar los nodos intermedios flotantes
//y aquellos dependientes de los flotantes
nodo = compo.OtherNode(nodo);
while (nodo != initialNode)
{
if (nodo.TypeOfNode == Node.NodeType.VoltageFixedNode)
{
// nothing, node was calculated
}
else if (compo is VoltageGenerator || compo is Capacitor)
{
if (nodo.TypeOfNode == Node.NodeType.Unknow)
nodo.TypeOfNode = Node.NodeType.VoltageLinkedNode;
else
throw new NotImplementedException();
}
else if (compo is Resistor)
{
if (nodo.TypeOfNode == Node.NodeType.Unknow)
nodo.TypeOfNode = Node.NodeType.VoltageDivideNode;
else
throw new NotImplementedException();
}
else if (compo is Inductor || compo is CurrentGenerator)
{
//nada, solo imponen la corriente
}
else
{
if (nodo.TypeOfNode == Node.NodeType.Unknow)
nodo.TypeOfNode = Node.NodeType.InternalBranchNode;
else
throw new NotImplementedException();
}
compo = nodo.OtherComponent(compo);
nodo = compo.OtherNode(nodo);
}
return br;
}
public override bool Solve(Circuit cir, BasicAnalysis ana)
{
List<Node> nodos = new List<Node>();
Voltages = new Dictionary<double, Dictionary<string, Complex32>>();
Currents = new Dictionary<double, Dictionary<string, Complex32>>();
//List<Node> nodosnorton;
//List<Node> nodoscalculables;
//List<SpecialComponentInfo> specialcomponents;
SolveInfo solveinfo = new SolveInfo();
PreAnalizeToSolve(cir, nodos, solveinfo);
ACAnalysis analis = ana as ACAnalysis;
double w, wi, wf, deltaw, wx, pow = 1;
wi = StringUtils.DecodeString(analis.StartFrequency);
wf = StringUtils.DecodeString(analis.EndFrequency);
w = wi;
int i = (int)Math.Log10(wi) + 1;
wx = Math.Pow(10, i);
if (analis.ScanType == ACAnalysis.ACAnalysisScan.Linear)
deltaw = (wf - wi) / analis.Points;
else
{
deltaw = 1.0d / analis.Points;
pow = Math.Pow(10, deltaw);
}
while (w < wf)
{
//Calculo de tensiones de nodos
Complex32 W = new Complex32(0, (float)w);
Calculate(solveinfo, W);
Dictionary<string, Complex32> result = new Dictionary<string, Complex32>();
#region almacenamiento temporal
foreach (var nodo in nodos)
{
result.Add(nodo.Name, nodo.Voltage);
}
if (!Voltages.ContainsKey(w))
Voltages.Add(w, result);
#endregion
//calculo las corrientes:
CalculateCurrents(cir, W);
Dictionary<string, Complex32> currents = new Dictionary<string, Complex32>();
StorageCurrents(cir, currents);
Currents.Add(w, currents);
if (analis.ScanType == ACAnalysis.ACAnalysisScan.Linear)
w += deltaw;
else
{
w = w * pow;
if (w > 0.95 * wx)
{
i++;
wi = wx;
wx = Math.Pow(10, i);
w = wi;
}
}
}
cir.State = Circuit.CircuitState.Solved;
return true;
}
static void Main(string[] args)
{
int i = 2;
switch (i)
{
case 0:
cir.ReadCircuit("circuits/RLcharge.net");
cir2 = (Circuit)cir.Clone();
DCSolver.Optimize(cir2);
DCAnalysis ac0 = (DCAnalysis)cir2.Setup[0];
DCSolver solver = (DCSolver)ac0.Solver;
//solver.Solve(cir2, );
cir2.Solve();
solver.ExportToCSV("e:/Test.csv");
break;
case 1:
cir.ReadCircuit("circuits/testidc.net");
cir2 = (Circuit)cir.Clone();
DCSolver.Optimize(cir2);
DCAnalysis ac3 = (DCAnalysis)cir2.Setup[0];
DCSolver solver3 = (DCSolver)ac3.Solver;
//solver.Solve(cir2, );
cir2.Solve();
solver3.ExportToCSV("e:/Test.csv");
break;
case 2:
cir.ReadCircuit("circuits/derivador.net");
//cir.ReadCircuit("RCL.net");
cir2 = (Circuit)cir.Clone();
cir2.Setup.RemoveAt(0);
ACAnalysis ac = new ACAnalysis();
cir2.Setup.Add(ac);
ACSweepSolver.Optimize(cir2);
cir2.Solve();
ACSweepSolver sol = (ACSweepSolver)ac.Solver;
sol.ExportToCSV("ACSweep.csv");
break;
case 3:
//cir.ReadCircuit("derivador.net");
cir.ReadCircuit("circuits/RLC.net");
cir2 = (Circuit)cir.Clone();
cir2.Setup.RemoveAt(0);
ComplexPlainAnalysis ac1 = new ComplexPlainAnalysis();
cir2.Setup.Add(ac1);
ACSweepSolver.Optimize(cir2);
cir2.Solve();
sol1 = (ComplexPlainSolver)ac1.Solver;
sol1.SelectedNode = sol1.CurrentCircuit.Nodes["out"];
// sol1.
sol1.ExportToCSV("e:/plain.csv");
Bitmap bmp = FileUtils.DrawImage(func, ac1.Points, ac1.Points);
bmp.Save("e:/plain.bmp");
break;
case 4:
cir.ReadCircuit("circuits/RCL.net");
//cir.ReadCircuit("RCcharge.net");
cir2 = (Circuit)cir.Clone();
cir2.Setup.RemoveAt(0);
TransientAnalysis ac5 = new TransientAnalysis();
ac5.Step = "10n";
cir2.Setup.Add(ac5);
TransientSolver sol5 = (TransientSolver)ac5.Solver;
TransientSolver.Optimize(cir2);
cir2.Solve();
sol5.ExportToCSV("e:/time.csv");
break;
case 5:
cir.ReadCircuit("circuits/vsingain.net");
//cir.ReadCircuit("RCcharge.net");
cir2 = (Circuit)cir.Clone();
cir2.Setup.RemoveAt(0);
TransientAnalysis ac6 = new TransientAnalysis();
ac6.Step = "100n";
cir2.Setup.Add(ac6);
TransientSolver sol6 = (TransientSolver)ac6.Solver;
TransientSolver.Optimize(cir2);
cir2.Solve();
sol6.ExportToCSV("e:/time.csv");
break;
default:
break;
}
Console.ReadKey();
}
public override bool Solve(Circuit cir, BasicAnalysis ana)
{
List<Node> nodos = new List<Node>();
CurrentAnalysis = ana as ComplexPlainAnalysis;
CurrentCircuit = cir;
//List<Node> nodosnorton = new List<Node>();
//List<Node> nodoscalculables = new List<Node>();
//List<SpecialComponentInfo> especialcomponents;
Voltages = new Dictionary<Complex32, Dictionary<string, Complex32>>();
Currents = new Dictionary<Complex32, Dictionary<string, Complex32>>();
WfromIndexes = new Dictionary<Tuple<int, int>, Complex32>();
SolveInfo solveinfo = new SolveInfo();
PreAnalizeToSolve(cir, nodos, solveinfo);
ComplexPlainAnalysis analis = ana as ComplexPlainAnalysis;
double w, sig, wi, wf, deltaw, deltasig, sigmamin, sigmamax;
wi = analis.WMin;
wf = analis.WMax;
sigmamax = analis.SigmaMax;
sigmamin = analis.SigmaMin;
w = wi;
sig = sigmamin;
deltaw = (wf - wi) / analis.Points;
deltasig = (sigmamax - sigmamin) / analis.Points;
Complex32 W = Complex32.Zero;
for (int i = 0; i <= analis.Points; i++)
{
for (int j = 0; j <= analis.Points; j++)
{
//Calculo de tensiones de nodos
W = new Complex32((float)(sigmamin + j * deltasig), (float)(wi + i * deltaw));
ACSweepSolver.Calculate(solveinfo, W);
// Node Voltage
Dictionary<string, Complex32> result = new Dictionary<string, Complex32>();
#region almacenamiento temporal
foreach (var nodo in nodos)
{
result.Add(nodo.Name, nodo.Voltage);
}
if (!Voltages.ContainsKey(W))
{
Voltages.Add(W, result);
WfromIndexes.Add(new Tuple<int, int>(i, j), W);
}
else
{
throw new NotImplementedException();
}
// Results[i,j] = new Tuple<Complex32,Complex32>(W,
#endregion
//calculo las corrientes:
CalculateCurrents(cir, W);
Dictionary<string, Complex32> currents = new Dictionary<string, Complex32>();
StorageCurrents(cir, currents);
Currents.Add(W, currents);
}
}
cir.State = Circuit.CircuitState.Solved;
return true;
}
private void Simulate(string FileName)
{
cir = new Circuit();
cir.ReadCircuit(FileName);
cir2 = (Circuit)cir.Clone();
cir2.Setup.RemoveAt(0);
ac1 = new ComplexPlainAnalysis();
cir2.Setup.Add(ac1);
ACSweepSolver.Optimize(cir2);
Update();
lbComponents.ItemsSource = cir.Components;
lbNodes.ItemsSource = cir.Nodes.Values;
//lbComponents.SelectedItem
DataContext = model;
}
public virtual bool Solve(Circuit cir, BasicAnalysis ana)
{
//int fila = 0;
List<Node> nodos = new List<Node>();
circuit = cir;
if (cir.Reference == null)
{
foreach (var nodo in cir.Nodes.Values)
{
//creo una lista de nodos sin el nodo referencia
if (!nodo.IsReference)
nodos.Add(nodo);
}
}
else
{
nodos.AddRange(cir.Nodes.Values);
nodos.Remove(cir.Reference);
}
List<Node> nodosnorton = new List<Node>();
List<Node> nortoncopia = new List<Node>();
foreach (var nodo in nodos)
{
if (nodo.TypeOfNode == Node.NodeType.MultibranchCurrentNode ||
nodo.TypeOfNode == Node.NodeType.VoltageLinkedNode ||
nodo.TypeOfNode == Node.NodeType.VoltageDivideNode)
nodosnorton.Add(nodo);
}
#region Calculo de tensiones de nodos
nortoncopia.Clear();
foreach (var item in nodosnorton)
{
nortoncopia.Add(item);
}
Calculate(nortoncopia);
#endregion
//#region almacenamiento temporal
//#endregion
//calculo las corrientes:
CalculateCurrents(cir);
cir.State = Circuit.CircuitState.Solved;
return true;
}
protected static void AddComponentNodes(Circuit ciroptimizado, Dipole rama)
{
if (!ciroptimizado.Nodes.ContainsValue(rama.Nodes[0]))
ciroptimizado.Nodes.Add(rama.Nodes[0].Name, rama.Nodes[0]);
if (!ciroptimizado.Nodes.ContainsValue(rama.Nodes[1]))
ciroptimizado.Nodes.Add(rama.Nodes[1].Name, rama.Nodes[1]);
}
