public TransformerView(DataVertex dv)
{
InitializeComponent();
this.dv = dv;
this._mn = App.Current.MainWindow as MainWindow;
this.globalVertices = _mn.GlobalVertices;
this.globalEdges = _mn.GlobalEdges;
DataVertexTransformer dataVertexTransformer = (DataVertexTransformer)dv;
//if node already consist some data
if (dataVertexTransformer.NameA != null)
{
populateViewIfObjectExists(dataVertexTransformer);
}
if ((_mn.graphView.DataContext as GraphViewModel).dvtp != null)
{
lineTo.Text = (_mn.graphView.DataContext as GraphViewModel).dvtp.Element_id;
last_value = lineTo.Text;
lineTo.IsReadOnly = true;
}
else
{
//lineTo.Text = dataVertexTransformer.Line_to;
//lineTo.IsReadOnly = true;
}
setupViewDeafultValues();
}
private DataVertexTransformer setupDataVertexTransformerProperties()
{
DataVertexTransformer dataVertexTransformer = new DataVertexTransformer()
{
//populate data
Text = dv.Text,
Element_id = linefrom.Text,
typeOfVertex = dv.typeOfVertex,
NameA = first_name.Text,
NameB = second_name.Text,
_kVA_A = Double.Parse(apparent_power_first_part.Text),
_kVA_B = Double.Parse(apparent_power_second_part.Text),
_kV_HighA = Double.Parse(high_limit_first_part.Text),
_kV_HighB = Double.Parse(high_limit_second_part.Text),
_kV_LowA = Double.Parse(low_limit_first_part.Text),
_kV_LowB = Double.Parse(low_limit_second_part.Text),
RPercentageA = Double.Parse(r_percentage__first_part.Text),
RPercentageB = Double.Parse(r_percentage__second_part.Text),
XPercentageA = Double.Parse(x_percentage__first_part.Text),
XPercentageB = Double.Parse(x_percentage__second_part.Text),
Line_from = linefrom.Text,
Line_to = lineTo.Text
};
return(dataVertexTransformer);
}
private void CreateTransformerVertex(DataVertex dv, double m = 0, double n = 0)
{
VertexControl vc;
if (dvt != null)
{
MessageBox.Show("Transformer already created");
return;
}
dvt = new DataVertexTransformer()
{
Text = "First transfromer ending: " + dv.Element_id,
Element_id = dv.Element_id
};
dvt.typeOfVertex = DataVertex.TypeOfVertex.TRANSFORMER_VERTEX;
vc = new VertexControl(dvt);
if (m == 0)
{
vc.SetPosition(new Point(x, y));
}
else
{
vc.SetPosition(m, n);
}
mainWindow.GlobalVertices.Add(dvt.Element_id, dvt);
vc.Background = Brushes.GreenYellow;
mainWindow.graphView.Area.AddVertexAndData(dvt, vc, true);
Point point = CreatePointBasedOn(vc);
if (graphState == GraphState.NORMAL)
{
x += 30;
y += 30;
}
return;
}
public void PrepareComplexVertexForDelete(DataVertex dv)
{
VertexControl vc = GetVertexControlWithDataVertex(dv.Element_id);
Point p = CreatePointBasedOn(vc);
DeleteVertex(dv);
if (dv.typeOfVertex == DataVertex.TypeOfVertex.REGULATOR_VERTEX)
{
dvr = (DataVertexRegulator)dv;
if (dvr.Line_Segment_To != null)
{
if (mainWindow.GlobalVertices.Keys.Contains(dvr.Line_Segment_To))
{
DeleteVertex(mainWindow.GlobalVertices[dvr.Line_Segment_To]);
mainWindow.GlobalVertices.Remove(dvr.Line_Segment_To);
dvrp = null;
}
}
dvr = null;
}
else if (dv.typeOfVertex == DataVertex.TypeOfVertex.TRANSFORMER_VERTEX)
{
dvt = (DataVertexTransformer)dv;
if (dvt.Line_to != null)
{
if (mainWindow.GlobalVertices.Keys.Contains(dvt.Line_to))
{
DeleteVertex(mainWindow.GlobalVertices[dvt.Line_to]);
mainWindow.GlobalVertices.Remove(dvt.Line_to);
dvtp = null;
}
}
dvt = null;
}
mainWindow.enableButtonIfEdgesExists();
mainWindow.CloseAllWindows();
}
private void populateViewIfObjectExists(DataVertexTransformer dataVertexTransformer)
{
dynamicButton.Content = "Update";
dynamicButton2.IsEnabled = true;
first_name.Text = dataVertexTransformer.NameA;
second_name.Text = dataVertexTransformer.NameB;
second_component = dataVertexTransformer.Line_to;
apparent_power_first_part.Text = dataVertexTransformer._kVA_A.ToString();
apparent_power_second_part.Text = dataVertexTransformer._kVA_B.ToString();
high_limit_first_part.Text = dataVertexTransformer._kV_HighA.ToString();
low_limit_first_part.Text = dataVertexTransformer._kV_LowA.ToString();
high_limit_second_part.Text = dataVertexTransformer._kV_HighB.ToString();
low_limit_second_part.Text = dataVertexTransformer._kV_LowB.ToString();
r_percentage__first_part.Text = dataVertexTransformer.RPercentageA.ToString();
r_percentage__second_part.Text = dataVertexTransformer.RPercentageB.ToString();
x_percentage__first_part.Text = dataVertexTransformer.XPercentageA.ToString();
x_percentage__second_part.Text = dataVertexTransformer.XPercentageB.ToString();
last_value = lineTo.Text;
}
public Dictionary <Type, Dictionary <string, IdentifiedObject> > CreateObjectModel(Dictionary <string, DataVertex> globalVertices, Dictionary <string, List <DataEdge> > globalEdges, Dictionary <string, CableConfiguration> globalCableConfiguration, Dictionary <string, SpotLoad> globalSpotLoads)
{
globalComponentDictionary = new Dictionary <Type, Dictionary <string, IdentifiedObject> >();
terminalPairsContainer = new List <TerminalPair>();
perLengthImpedanceContainer = new Dictionary <string, PerLengthImpedance>();
wireInfoContainer = new Dictionary <string, WireInfo>();
usagePointContainer = new Dictionary <string, SpotLoad>();
powerTransformerEnding = new Dictionary <string, DataVertexTransformer>();
PSRType local_psr_pt = new PSRType();
circuit = new Circuit();
string mrid = Guid.NewGuid().ToString();
PSRType psrTypeCircuit = new PSRType()
{
MRID = "Feeder", Name = "Feeder"
};
circuit.PSRType = psrTypeCircuit;
circuit.ID = mrid;
circuit.MRID = mrid;
circuit.Name = "Feeder_36";
addComponentToGlobalDictionary(circuit, circuit.GetType());
addComponentToGlobalDictionary(psrTypeCircuit, psrTypeCircuit.GetType());
Dictionary <string, ConnectivityNode> connectivityNodeContainer = new Dictionary <string, ConnectivityNode>();
foreach (DataVertex dataVertex in globalVertices.Values)
{
if (dataVertex.typeOfVertex == DataVertex.TypeOfVertex.TRANSFORMER_VERTEX)
{
PowerTransformer powerTransformer = new PowerTransformer();
DataVertexTransformer dvt = (DataVertexTransformer)dataVertex;
string power_transformer_mrid = Guid.NewGuid().ToString();
powerTransformer.ID = power_transformer_mrid;
powerTransformer.MRID = power_transformer_mrid;
powerTransformer.Name = "2 winding power transformer";
local_psr_pt = new PSRType()
{
Name = "Consumer Transformer", MRID = "Consumer Transformer"
};
powerTransformer.PSRType = local_psr_pt;
powerTransformer.EquipmentContainer = circuit;
addComponentToGlobalDictionary(local_psr_pt, local_psr_pt.GetType());
ConnectivityNode w1T_cn = new ConnectivityNode();
string connectivity_node_mrid = Guid.NewGuid().ToString();
w1T_cn.ID = connectivity_node_mrid;
w1T_cn.MRID = connectivity_node_mrid;
w1T_cn.ConnectivityNodeContainer = circuit;
if ((dataVertex as DataVertexTransformer).Line_from == null)
{
continue;
}
;
w1T_cn.Name = (dataVertex as DataVertexTransformer).Line_from;
connectivityNodeContainer.Add((dataVertex as DataVertexTransformer).Line_from, w1T_cn);
addComponentToGlobalDictionary(w1T_cn, w1T_cn.GetType());
ConnectivityNode w2T_cn = new ConnectivityNode();
connectivity_node_mrid = Guid.NewGuid().ToString();
w2T_cn.ID = connectivity_node_mrid;
w2T_cn.MRID = connectivity_node_mrid;
w2T_cn.ConnectivityNodeContainer = circuit;
w2T_cn.Name = (dataVertex as DataVertexTransformer).Line_to;
connectivityNodeContainer.Add((dataVertex as DataVertexTransformer).Line_to, w2T_cn);
if ((dataVertex as DataVertexTransformer).Line_to == null)
{
continue;
}
;
addComponentToGlobalDictionary(w2T_cn, w2T_cn.GetType());
Terminal w1T = new Terminal();
w1T.MRID = power_transformer_mrid + ".W1.T";
w1T.ID = power_transformer_mrid + ".W1.T";
w1T.SequenceNumber = 1;
w1T.ConductingEquipment = powerTransformer;
w1T.ConnectivityNode = w1T_cn;
w1T.Phases = PhaseCode.s2N;
w1T.Name = "Transformer end terminal 1";
Terminal w2T = new Terminal();
w2T.MRID = power_transformer_mrid + ".W2.T";
w2T.ID = power_transformer_mrid + ".W2.T";
w2T.SequenceNumber = 2;
w2T.ConductingEquipment = powerTransformer;
w2T.ConnectivityNode = w2T_cn;
w2T.Phases = PhaseCode.s2N;
w2T.Name = "Transformer end terminal 2";
terminalPairsContainer.Add(new TerminalPair()
{
terminalA = w1T, terminalB = w2T
});
addComponentToGlobalDictionary(w1T, w1T.GetType());
addComponentToGlobalDictionary(w2T, w2T.GetType());
PowerTransformerEnd powerTransformerEnd1 = new PowerTransformerEnd();
powerTransformerEnd1.ID = power_transformer_mrid + ".W1";
powerTransformerEnd1.MRID = power_transformer_mrid + ".W1";
powerTransformerEnd1.Name = dvt.NameA;
powerTransformerEnd1.Terminal = w1T;
powerTransformerEnd1.Grounded = false;
powerTransformerEnd1.EndNumber = 1;
powerTransformerEnd1.PowerTransformer = powerTransformer;
powerTransformerEnd1.ConnectionKind = WindingConnection.D;
powerTransformerEnd1.PhaseAngleClock = 0;
powerTransformerEnd1.RatedS = (float)dvt._kVA_A;
powerTransformerEnd1.RatedU = (float)dvt._kV_LowA;
PowerTransformerEnd powerTransformerEnd2 = new PowerTransformerEnd();
powerTransformerEnd2.ID = power_transformer_mrid + ".W2";
powerTransformerEnd2.MRID = power_transformer_mrid + ".W2";
powerTransformerEnd2.Name = dvt.NameB;
powerTransformerEnd2.Terminal = w2T;
powerTransformerEnd2.Grounded = false;
powerTransformerEnd2.EndNumber = 1;
powerTransformerEnd2.PowerTransformer = powerTransformer;
powerTransformerEnd2.ConnectionKind = WindingConnection.D;
powerTransformerEnd2.PhaseAngleClock = 0;
powerTransformerEnd2.RatedS = (float)dvt._kVA_B;
powerTransformerEnd2.RatedU = (float)dvt._kV_LowB;
addComponentToGlobalDictionary(powerTransformer, powerTransformer.GetType());
addComponentToGlobalDictionary(powerTransformerEnd1, powerTransformerEnd1.GetType());
addComponentToGlobalDictionary(powerTransformerEnd2, powerTransformerEnd2.GetType());
}
if (dataVertex.typeOfVertex == DataVertex.TypeOfVertex.REGULATOR_VERTEX)
{
string sync_machine = Guid.NewGuid().ToString();
PSRType psr_sync_machine = new PSRType()
{
MRID = "Generator",
Name = "Generator"
};
SynchronousMachine sm = new SynchronousMachine()
{
Name = dataVertex.Text,
MRID = sync_machine,
ID = sync_machine,
EquipmentContainer = circuit
};
addComponentToGlobalDictionary(sm, sm.GetType());
addComponentToGlobalDictionary(psr_sync_machine, psr_sync_machine.GetType());
}
}
foreach (List <DataEdge> dataEdgeCollection in globalEdges.Values)
{
foreach (DataEdge dataEdge in dataEdgeCollection)
{
string acLineSegment_mrid = Guid.NewGuid().ToString();
ConnectivityNode T1_cn = new ConnectivityNode();
string connectivity_node_mrid = Guid.NewGuid().ToString();
T1_cn.ID = connectivity_node_mrid;
T1_cn.MRID = connectivity_node_mrid;
T1_cn.ConnectivityNodeContainer = circuit;
T1_cn.Name = (dataEdge.Source as DataVertex).Element_id;
if (connectivityNodeContainer.ContainsKey((dataEdge.Source as DataVertex).Element_id) == false)
{
connectivityNodeContainer.Add(dataEdge.Source.Element_id, T1_cn);
addComponentToGlobalDictionary(T1_cn, T1_cn.GetType());
}
ConnectivityNode T2_cn = new ConnectivityNode();
connectivity_node_mrid = Guid.NewGuid().ToString();
T2_cn.ID = connectivity_node_mrid;
T2_cn.MRID = connectivity_node_mrid;
T2_cn.ConnectivityNodeContainer = circuit;
T2_cn.Name = (dataEdge.Target as DataVertex).Element_id;
if (connectivityNodeContainer.ContainsKey((dataEdge.Target as DataVertex).Element_id) == false)
{
connectivityNodeContainer.Add(dataEdge.Target.Element_id, T2_cn);
addComponentToGlobalDictionary(T2_cn, T2_cn.GetType());
}
Terminal T1 = new Terminal();
//string terminal_mrid = Guid.NewGuid().ToString();
T1.ID = acLineSegment_mrid + ".T1";
T1.MRID = acLineSegment_mrid + ".T1";
T1.Name = dataEdge.Source.Element_id;
T1.Phases = PhaseCode.ABC;
ACDCTerminal acdc_terminal = new ACDCTerminal()
{
SequenceNumber = 1
};
T1.SequenceNumber = acdc_terminal.SequenceNumber;
T1.ConnectivityNode = T1_cn;
Terminal T2 = new Terminal();
T2.ID = acLineSegment_mrid + ".T2";
T2.MRID = acLineSegment_mrid + ".T2";
T2.Name = dataEdge.Target.Element_id;
T2.Phases = PhaseCode.ABC;
ACDCTerminal acdc_terminal2 = new ACDCTerminal()
{
SequenceNumber = 2
};
T2.SequenceNumber = acdc_terminal2.SequenceNumber;
T2.ConnectivityNode = T2_cn;
string perLengthImpedance_mrid = Guid.NewGuid().ToString();
PerLengthImpedance pli = createPerLengthImpedanceObject(dataEdge.Configuration, perLengthImpedance_mrid);
AssetInfo wi = createWireInfoObject(dataEdge.Configuration, perLengthImpedance_mrid);
PSRType acPSRType = new PSRType()
{
MRID = "Section",
Name = "Section"
};
if (!globalComponentDictionary[acPSRType.GetType()].ContainsKey(acPSRType.Name))
{
addComponentToGlobalDictionary(acPSRType, acPSRType.GetType());
}
ACLineSegment acLineSegment = new ACLineSegment()
{
ID = acLineSegment_mrid,
MRID = acLineSegment_mrid,
Name = T1.Name.Split(' ').Last() + "-" + T2.Name.Split(' ').Last(),
PSRType = acPSRType,
EquipmentContainer = circuit,
Length = (float)feetsToMeters(dataEdge.Length),
PerLengthImpedance = pli,
AssetDatasheet = wi
};
addComponentToGlobalDictionary(acLineSegment, acLineSegment.GetType());
TerminalPair terminalPair = new TerminalPair()
{
terminalA = T1,
terminalB = T2
};
terminalPairsContainer.Add(terminalPair);
addComponentToGlobalDictionary(T1, T1.GetType());
addComponentToGlobalDictionary(T2, T2.GetType());
}
}
UsagePoint usagePoint = new UsagePoint();
foreach (DataVertex dv in globalVertices.Values)
{
if (dv.typeOfVertex == DataVertex.TypeOfVertex.SPOT_LOAD_VERTEX)
{
SpotLoad sl = (SpotLoad)dv;
usagePoint = CreateSpotLoad(sl);
addComponentToGlobalDictionary(usagePoint, usagePoint.GetType());
}
}
return(globalComponentDictionary);
}
public void DeleteVertex(DataVertex dv)
{
//Area.RemoveVertex(globalVertices[dv.Text]);
mainWindow.GlobalVertices.Remove(dv.Element_id);
Console.WriteLine(mainWindow.GlobalVertices);
bool is_empty = true;
bool has_edge = false;
is_empty = CheckIfZeroEdgesExist();
//if 0 edges exist we can remove it
RemoveIfZeroEdgesExist(is_empty, dv.Element_id);
//if more then 0 edges exist we look for them
has_edge = RemoveIfMoreThenZeroEdgesExist(dv);
//if its not empty and its has edges, its third case, we delete it
if (!is_empty && !has_edge)
{
VertexControl vc = GetVertexControlWithDataVertex(dv.Element_id);
if (vc == null)
{
return;
}
mainWindow.graphView.Area.RemoveVertex((vc.Vertex as DataVertex));
}
if (dv.typeOfVertex == DataVertex.TypeOfVertex.REGULATOR_VERTEX)
{
dvr = null;
if (dvrp != null)
{
DeleteVertex(dvrp);
dvrp = null;
}
}
if (dv.typeOfVertex == DataVertex.TypeOfVertex.TRANSFORMER_VERTEX)
{
dvt = null;
if (dvtp != null)
{
DeleteVertex(dvtp);
dvtp = null;
}
}
//now we look for his edges and delete them
foreach (string key in mainWindow.GlobalEdges.Keys)
{
foreach (DataEdge de in mainWindow.GlobalEdges[key])
{
if (de.Target.Element_id == dv.Element_id)
{
mainWindow.GlobalEdges[key].Remove(de);
if (mainWindow.graphView.Area.EdgesList.ContainsKey(de))
{
mainWindow.graphView.Area.RemoveEdge(de);
break;
}
}
}
}
if (dv.typeOfVertex == DataVertex.TypeOfVertex.REGULATOR_PARTIAL_VERTEX || dv.typeOfVertex == DataVertex.TypeOfVertex.TRANSFORMER_PARTIAL_VERTEX)
{
foreach (DataVertex temp in mainWindow.graphView.Area.VertexList.Keys)
{
if (temp.Element_id == dv.Element_id)
{
mainWindow.graphView.Area.RemoveVertex(temp);
break;
}
}
}
if (graphState == GraphState.NORMAL)
{
undoRedoCommander.addUndoCommand(new Command("DeleteVertex", dv));
}
}
private void dynamicButton_Click(object sender, RoutedEventArgs e)
{
if (!allFilled())
{
MessageBox.Show("You have to enter all data");
return;
}
if ((_mn.graphView.DataContext as GraphViewModel).dvtp == null)
{
if (globalVertices.ContainsKey(lineTo.Text) && second_component != lineTo.Text)
{
MessageBox.Show("Node with that ID already exists, change Line segment to input.");
return;
}
}
DataVertexTransformer dataVertexTransformer = setupDataVertexTransformerProperties();
DataVertexTransformerPartial dvtp;
if ((_mn.graphView.DataContext as GraphViewModel).dvtp != null)
{
dvtp = (_mn.graphView.DataContext as GraphViewModel).dvtp;
dvtp.Text = "Second transformer ending: " + lineTo.Text;
dynamicButton.Content = "Update";
}
else
{
DataVertexTransformerPartial dataVertexTransformerPartial = new DataVertexTransformerPartial()
{
Text = "Second transformer ending: " + lineTo.Text,
typeOfVertex = DataVertex.TypeOfVertex.TRANSFORMER_PARTIAL_VERTEX,
Element_id = dataVertexTransformer.Line_to,
Name = dataVertexTransformer.NameB,
_kVA = dataVertexTransformer._kVA_B,
_kV_High = dataVertexTransformer._kV_HighB,
_kV_Low = dataVertexTransformer._kV_LowB,
RPercentage = dataVertexTransformer.RPercentageB,
XPercentage = dataVertexTransformer.XPercentageB
};
(_mn.graphView.DataContext as GraphViewModel).dvtp = dataVertexTransformerPartial;
dvtp = dataVertexTransformerPartial;
}
dvtp.Element_id = lineTo.Text;
if (dynamicButton.Content.ToString() == "Update")
{
(_mn.graphView.DataContext as GraphViewModel).graphState = GraphViewModel.GraphState.UPDATE;
(_mn.graphView.DataContext as GraphViewModel).UpdateVertices(dataVertexTransformer, dvtp, last_value);
(_mn.graphView.DataContext as GraphViewModel).graphState = GraphViewModel.GraphState.NORMAL;
last_value = dataVertexTransformer.Line_to;
}
else
{
(_mn.graphView.DataContext as GraphViewModel).CreateComplexVertexWithPartialType(dataVertexTransformer, dvtp, dv);
}
_mn.CloseAllWindows();
}
