From 7075de4b71a96afb7ca7c6cc115a4ec542ac53a9 Mon Sep 17 00:00:00 2001 From: Thales1330 Date: Sat, 10 Dec 2016 17:18:31 -0200 Subject: Basic save methods implemented --- Project/FileHanding.cpp | 71 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 71 insertions(+) create mode 100644 Project/FileHanding.cpp (limited to 'Project/FileHanding.cpp') diff --git a/Project/FileHanding.cpp b/Project/FileHanding.cpp new file mode 100644 index 0000000..5611ca6 --- /dev/null +++ b/Project/FileHanding.cpp @@ -0,0 +1,71 @@ +#include "FileHanding.h" + +FileHanding::~FileHanding() {} + +FileHanding::FileHanding(Workspace* workspace) +{ + m_workspace = workspace; +} + +FileHanding::FileHanding() {} + +void FileHanding::SaveProject(wxFileName path) +{ + //Erase the file (if exists or not) and write the initial data + std::ofstream writeProjectsFile(path.GetFullPath()); + writeProjectsFile.close(); + + rapidxml::xml_document<> doc; + rapidxml::file<> xmlFile(path.GetFullPath()); + doc.parse<0>(xmlFile.data()); + + rapidxml::xml_node<>* decl = doc.allocate_node(rapidxml::node_declaration); + rapidxml::xml_attribute<>* ver = doc.allocate_attribute("version", "1.0"); + rapidxml::xml_attribute<>* encoding = doc.allocate_attribute("encoding", "utf-8"); + decl->append_attribute(ver); + decl->append_attribute(encoding); + doc.append_node(decl); + + rapidxml::xml_node<>* rootNode = doc.allocate_node(rapidxml::node_element, "Project"); + doc.append_node(rootNode); + + rapidxml::xml_node<>* projectNameNode = AppendNode(doc, rootNode, "Name"); + SetNodeValue(doc, projectNameNode, path.GetName()); + + //Save all the data + rapidxml::xml_node<>* testValues = AppendNode(doc, rootNode, "TestValues"); + rapidxml::xml_node<>* testDouble = AppendNode(doc, testValues, "TestDouble"); + SetNodeValue(doc, testDouble, 1.23456789123456789123456789); + rapidxml::xml_node<>* testInt = AppendNode(doc, testValues, "TestInt"); + SetNodeValue(doc, testInt, 123456789); + rapidxml::xml_node<>* testString = AppendNode(doc, testValues, "TestString"); + SetNodeValue(doc, testString, (wxString)"TESTE"); + + std::ofstream writeXML(path.GetFullPath()); + writeXML << doc; + writeXML.close(); +} + +void FileHanding::OpenProject(wxFileName path) {} + +rapidxml::xml_node<>* FileHanding::AppendNode(rapidxml::xml_document<>& doc, rapidxml::xml_node<>* parentNode, const char* name, rapidxml::node_type nodeType) +{ + rapidxml::xml_node<>* node = doc.allocate_node(nodeType, name); + parentNode->append_node(node); + return node; +} + +void FileHanding::SetNodeValue(rapidxml::xml_document<>& doc, rapidxml::xml_node<>* node, wxString value) +{ + node->value(doc.allocate_string(value.mb_str())); +} + +void FileHanding::SetNodeValue(rapidxml::xml_document<>& doc, rapidxml::xml_node<>* node, int value) +{ + node->value(doc.allocate_string(wxString::Format("%d", value))); +} + +void FileHanding::SetNodeValue(rapidxml::xml_document<>& doc, rapidxml::xml_node<>* node, double value) +{ + node->value(doc.allocate_string(wxString::FromCDouble(value, 13).mb_str())); +} -- cgit From ac9b62df34695e8c7f4fbb838c6126bd98671316 Mon Sep 17 00:00:00 2001 From: Thales1330 Date: Mon, 12 Dec 2016 21:12:51 -0200 Subject: Many elements save implemented --- Project/FileHanding.cpp | 495 ++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 480 insertions(+), 15 deletions(-) (limited to 'Project/FileHanding.cpp') diff --git a/Project/FileHanding.cpp b/Project/FileHanding.cpp index 5611ca6..c7a8759 100644 --- a/Project/FileHanding.cpp +++ b/Project/FileHanding.cpp @@ -2,16 +2,13 @@ FileHanding::~FileHanding() {} -FileHanding::FileHanding(Workspace* workspace) -{ - m_workspace = workspace; -} +FileHanding::FileHanding(Workspace* workspace) { m_workspace = workspace; } FileHanding::FileHanding() {} void FileHanding::SaveProject(wxFileName path) { - //Erase the file (if exists or not) and write the initial data + // Erase the file (if exists or not) and write the initial data std::ofstream writeProjectsFile(path.GetFullPath()); writeProjectsFile.close(); @@ -28,18 +25,458 @@ void FileHanding::SaveProject(wxFileName path) rapidxml::xml_node<>* rootNode = doc.allocate_node(rapidxml::node_element, "Project"); doc.append_node(rootNode); - + rapidxml::xml_node<>* projectNameNode = AppendNode(doc, rootNode, "Name"); SetNodeValue(doc, projectNameNode, path.GetName()); + + auto elementsNode = AppendNode(doc, rootNode, "Elements"); + + // Save all the data + ElectricCalculation allElements; + allElements.GetElementsFromList(m_workspace->GetElementList()); + + //{ Buses + auto busesNode = AppendNode(doc, elementsNode, "BusList"); + auto busList = allElements.GetBusList(); + for(int i = 0; i < (int)busList.size(); i++) { + Bus* bus = busList[i]; + auto busNode = AppendNode(doc, busesNode, "Bus"); + SetNodeAttribute(doc, busNode, "ID", i); + auto cadProp = AppendNode(doc, busNode, "CADProperties"); + auto position = AppendNode(doc, cadProp, "Position"); + auto posX = AppendNode(doc, position, "X"); + SetNodeValue(doc, posX, bus->GetPosition().m_x); + auto posY = AppendNode(doc, position, "Y"); + SetNodeValue(doc, posY, bus->GetPosition().m_y); + auto size = AppendNode(doc, cadProp, "Size"); + auto width = AppendNode(doc, size, "Width"); + SetNodeValue(doc, width, bus->GetWidth()); + auto height = AppendNode(doc, size, "Height"); + SetNodeValue(doc, height, bus->GetHeight()); + auto angle = AppendNode(doc, cadProp, "Angle"); + SetNodeValue(doc, angle, bus->GetAngle()); + + BusElectricalData data = bus->GetEletricalData(); + auto electricalProp = AppendNode(doc, busNode, "ElectricalProperties"); + auto name = AppendNode(doc, electricalProp, "Name"); + SetNodeValue(doc, name, data.name); + auto nominalVoltage = AppendNode(doc, electricalProp, "NominalVoltage"); + SetNodeValue(doc, nominalVoltage, data.nominalVoltage); + auto nominalVoltageUnit = AppendNode(doc, electricalProp, "NominalVoltageUnit"); + SetNodeValue(doc, nominalVoltageUnit, data.nominalVoltageUnit); + auto isVoltageControlled = AppendNode(doc, electricalProp, "IsVoltageControlled"); + SetNodeValue(doc, isVoltageControlled, data.isVoltageControlled); + auto controlledVoltage = AppendNode(doc, electricalProp, "ControlledVoltage"); + SetNodeValue(doc, controlledVoltage, data.controlledVoltage); + auto controlledVoltageUnitChoice = AppendNode(doc, electricalProp, "ControlledVoltageUnitChoice"); + SetNodeValue(doc, controlledVoltageUnitChoice, data.controlledVoltageUnitChoice); + auto slackBus = AppendNode(doc, electricalProp, "SlackBus"); + SetNodeValue(doc, slackBus, data.slackBus); + + auto fault = AppendNode(doc, electricalProp, "Fault"); + auto hasFault = AppendNode(doc, fault, "HasFault"); + SetNodeValue(doc, hasFault, data.hasFault); + auto faultType = AppendNode(doc, fault, "Type"); + SetNodeValue(doc, faultType, data.faultType); + auto faultLocation = AppendNode(doc, fault, "Location"); + SetNodeValue(doc, faultLocation, data.faultLocation); + auto faultResistance = AppendNode(doc, fault, "Resistance"); + SetNodeValue(doc, faultResistance, data.faultResistance); + auto faultReactance = AppendNode(doc, fault, "Reactance"); + SetNodeValue(doc, faultReactance, data.faultReactance); + + auto stability = AppendNode(doc, electricalProp, "Stability"); + auto plotBus = AppendNode(doc, stability, "Plot"); + SetNodeValue(doc, plotBus, data.plotBus); + auto stabHasFault = AppendNode(doc, stability, "HasFault"); + SetNodeValue(doc, stabHasFault, data.stabHasFault); + auto stabFaultTime = AppendNode(doc, stability, "FaultTime"); + SetNodeValue(doc, stabFaultTime, data.stabFaultTime); + auto stabFaultLength = AppendNode(doc, stability, "FaultLength"); + SetNodeValue(doc, stabFaultLength, data.stabFaultLength); + auto stabFaultResistance = AppendNode(doc, stability, "FaultResistance"); + SetNodeValue(doc, stabFaultResistance, data.stabFaultResistance); + auto stabFaultReactance = AppendNode(doc, stability, "FaultReactance"); + SetNodeValue(doc, stabFaultReactance, data.stabFaultReactance); + + data.number = i; + bus->SetElectricalData(data); + } //} + + //{ Capacitor + auto capacitorsNode = AppendNode(doc, elementsNode, "CapacitorList"); + auto capacitorList = allElements.GetCapacitorList(); + for(int i = 0; i < (int)capacitorList.size(); i++) { + Capacitor* capacitor = capacitorList[i]; + auto capacitorNode = AppendNode(doc, capacitorsNode, "Capacitor"); + auto cadProp = AppendNode(doc, capacitorNode, "CADProperties"); + auto position = AppendNode(doc, cadProp, "Position"); + auto posX = AppendNode(doc, position, "X"); + SetNodeValue(doc, posX, capacitor->GetPosition().m_x); + auto posY = AppendNode(doc, position, "Y"); + SetNodeValue(doc, posY, capacitor->GetPosition().m_y); + auto size = AppendNode(doc, cadProp, "Size"); + auto width = AppendNode(doc, size, "Width"); + SetNodeValue(doc, width, capacitor->GetWidth()); + auto height = AppendNode(doc, size, "Height"); + SetNodeValue(doc, height, capacitor->GetHeight()); + auto angle = AppendNode(doc, cadProp, "Angle"); + SetNodeValue(doc, angle, capacitor->GetAngle()); + auto parentID = AppendNode(doc, cadProp, "ParentID"); + Bus* parent = (Bus*)capacitor->GetParentList()[0]; + if(parent) SetNodeValue(doc, parentID, parent->GetEletricalData().number); + + CapacitorElectricalData data = capacitor->GetElectricalData(); + auto electricalProp = AppendNode(doc, capacitorNode, "ElectricalProperties"); + auto isOnline = AppendNode(doc, electricalProp, "IsOnline"); + SetNodeValue(doc, isOnline, capacitor->IsOnline()); + auto name = AppendNode(doc, capacitorNode, "Name"); + SetNodeValue(doc, name, data.name); + auto reactivePower = AppendNode(doc, electricalProp, "ReactivePower"); + SetNodeValue(doc, reactivePower, data.reactivePower); + auto reactivePowerUnit = AppendNode(doc, electricalProp, "ReactivePowerUnit"); + SetNodeValue(doc, reactivePowerUnit, data.reactivePowerUnit); + + auto switchingList = AppendNode(doc, electricalProp, "SwitchingList"); + SwitchingData swData = capacitor->GetSwitchingData(); + for(int j = 0; j < (int)swData.swType.size(); j++) { + auto switching = AppendNode(doc, switchingList, "Switching"); + SetNodeAttribute(doc, switching, "ID", j); + auto swType = AppendNode(doc, switching, "Type"); + SetNodeValue(doc, swType, swData.swType[j]); + auto swTime = AppendNode(doc, switching, "Time"); + SetNodeValue(doc, swTime, swData.swTime[j]); + } + } //} + + //{ IndMotor + auto indMotorsNode = AppendNode(doc, elementsNode, "IndMotorList"); + auto indMotorList = allElements.GetIndMotorList(); + for(int i = 0; i < (int)indMotorList.size(); i++) { + IndMotor* indMotor = indMotorList[i]; + auto indMotorNode = AppendNode(doc, indMotorsNode, "IndMotor"); + auto cadProp = AppendNode(doc, indMotorNode, "CADProperties"); + auto position = AppendNode(doc, cadProp, "Position"); + auto posX = AppendNode(doc, position, "X"); + SetNodeValue(doc, posX, indMotor->GetPosition().m_x); + auto posY = AppendNode(doc, position, "Y"); + SetNodeValue(doc, posY, indMotor->GetPosition().m_y); + auto size = AppendNode(doc, cadProp, "Size"); + auto width = AppendNode(doc, size, "Width"); + SetNodeValue(doc, width, indMotor->GetWidth()); + auto height = AppendNode(doc, size, "Height"); + SetNodeValue(doc, height, indMotor->GetHeight()); + auto angle = AppendNode(doc, cadProp, "Angle"); + SetNodeValue(doc, angle, indMotor->GetAngle()); + auto parentID = AppendNode(doc, cadProp, "ParentID"); + SetNodeValue(doc, parentID, ((Bus*)indMotor->GetParentList()[0])->GetEletricalData().number); + + IndMotorElectricalData data = indMotor->GetElectricalData(); + auto electricalProp = AppendNode(doc, indMotorNode, "ElectricalProperties"); + auto isOnline = AppendNode(doc, electricalProp, "IsOnline"); + SetNodeValue(doc, isOnline, indMotor->IsOnline()); + auto name = AppendNode(doc, electricalProp, "Name"); + SetNodeValue(doc, name, data.name); + auto activePower = AppendNode(doc, electricalProp, "ActivePower"); + SetNodeValue(doc, activePower, data.activePower); + auto activePowerUnit = AppendNode(doc, electricalProp, "ActivePowerUnit"); + SetNodeValue(doc, activePowerUnit, data.activePowerUnit); + auto reactivePower = AppendNode(doc, electricalProp, "ReactivePower"); + SetNodeValue(doc, reactivePower, data.reactivePower); + auto reactivePowerUnit = AppendNode(doc, electricalProp, "ReactivePowerUnit"); + SetNodeValue(doc, reactivePowerUnit, data.reactivePowerUnit); + } //} + + //{ Inductor + auto inductorsNode = AppendNode(doc, elementsNode, "InductorList"); + auto inductorList = allElements.GetInductorList(); + for(int i = 0; i < (int)inductorList.size(); i++) { + Inductor* inductor = inductorList[i]; + auto inductorNode = AppendNode(doc, inductorsNode, "Inductor"); + auto cadProp = AppendNode(doc, inductorNode, "CADProperties"); + auto position = AppendNode(doc, cadProp, "Position"); + auto posX = AppendNode(doc, position, "X"); + SetNodeValue(doc, posX, inductor->GetPosition().m_x); + auto posY = AppendNode(doc, position, "Y"); + SetNodeValue(doc, posY, inductor->GetPosition().m_y); + auto size = AppendNode(doc, cadProp, "Size"); + auto width = AppendNode(doc, size, "Width"); + SetNodeValue(doc, width, inductor->GetWidth()); + auto height = AppendNode(doc, size, "Height"); + SetNodeValue(doc, height, inductor->GetHeight()); + auto angle = AppendNode(doc, cadProp, "Angle"); + SetNodeValue(doc, angle, inductor->GetAngle()); + auto nodePos = AppendNode(doc, cadProp, "NodePosition"); + auto nodePosX = AppendNode(doc, nodePos, "X"); + SetNodeValue(doc, nodePosX, inductor->GetPointList()[0].m_x); + auto nodePosY = AppendNode(doc, nodePos, "Y"); + SetNodeValue(doc, nodePosY, inductor->GetPointList()[0].m_y); + auto parentID = AppendNode(doc, cadProp, "ParentID"); + Bus* parent = (Bus*)inductor->GetParentList()[0]; + if(parent) SetNodeValue(doc, parentID, parent->GetEletricalData().number); + + InductorElectricalData data = inductor->GetElectricalData(); + auto electricalProp = AppendNode(doc, inductorNode, "ElectricalProperties"); + auto isOnline = AppendNode(doc, electricalProp, "IsOnline"); + SetNodeValue(doc, isOnline, inductor->IsOnline()); + auto name = AppendNode(doc, electricalProp, "Name"); + SetNodeValue(doc, name, data.name); + auto reactivePower = AppendNode(doc, electricalProp, "ReactivePower"); + SetNodeValue(doc, reactivePower, data.reactivePower); + auto reactivePowerUnit = AppendNode(doc, electricalProp, "ReactivePowerUnit"); + SetNodeValue(doc, reactivePowerUnit, data.reactivePowerUnit); + + auto switchingList = AppendNode(doc, electricalProp, "SwitchingList"); + SwitchingData swData = inductor->GetSwitchingData(); + for(int j = 0; j < (int)swData.swType.size(); j++) { + auto switching = AppendNode(doc, switchingList, "Switching"); + SetNodeAttribute(doc, switching, "ID", j); + auto swType = AppendNode(doc, switching, "Type"); + SetNodeValue(doc, swType, swData.swType[j]); + auto swTime = AppendNode(doc, switching, "Time"); + SetNodeValue(doc, swTime, swData.swTime[j]); + } + } //} + + //{ Line + auto linesNode = AppendNode(doc, elementsNode, "LineList"); + auto lineList = allElements.GetLineList(); + for(int i = 0; i < (int)lineList.size(); i++) { + Line* line = lineList[i]; + auto lineNode = AppendNode(doc, linesNode, "Line"); + auto cadProp = AppendNode(doc, lineNode, "CADProperties"); + auto nodeList = AppendNode(doc, cadProp, "NodeList"); + auto ptList = line->GetPointList(); + int nodeID = 0; + for(int j = 0; j < (int)ptList.size(); j++) { + if((j != 1) && (j != (int)ptList.size() - 2)) { + auto nodePos = AppendNode(doc, nodeList, "Node"); + SetNodeAttribute(doc, nodePos, "ID", nodeID); + auto nodePosX = AppendNode(doc, nodePos, "X"); + SetNodeValue(doc, nodePosX, ptList[j].m_x); + auto nodePosY = AppendNode(doc, nodePos, "Y"); + SetNodeValue(doc, nodePosY, ptList[j].m_y); + nodeID++; + } + } + + auto parentIDList = AppendNode(doc, cadProp, "ParentIDList"); + for(int j = 0; j < (int)line->GetParentList().size(); j++) { + Bus* parent = (Bus*)line->GetParentList()[j]; + if(parent) { + auto parentID = AppendNode(doc, parentIDList, "ParentID"); + SetNodeAttribute(doc, parentID, "ID", j); + SetNodeValue(doc, parentID, parent->GetEletricalData().number); + } + } + + LineElectricalData data = line->GetElectricalData(); + auto electricalProp = AppendNode(doc, lineNode, "ElectricalProperties"); + auto isOnline = AppendNode(doc, electricalProp, "IsOnline"); + SetNodeValue(doc, isOnline, line->IsOnline()); + auto name = AppendNode(doc, electricalProp, "Name"); + SetNodeValue(doc, name, data.name); + auto nominalVoltage = AppendNode(doc, electricalProp, "NominalVoltage"); + SetNodeValue(doc, nominalVoltage, data.nominalVoltage); + auto nominalVoltageUnit = AppendNode(doc, electricalProp, "NominalVoltageUnit"); + SetNodeValue(doc, nominalVoltageUnit, data.nominalVoltageUnit); + auto nominalPower = AppendNode(doc, electricalProp, "NominalPower"); + SetNodeValue(doc, nominalPower, data.nominalPower); + auto nominalPowerUnit = AppendNode(doc, electricalProp, "NominalPowerUnit"); + SetNodeValue(doc, nominalPowerUnit, data.nominalPowerUnit); + auto resistance = AppendNode(doc, electricalProp, "Resistance"); + SetNodeValue(doc, resistance, data.resistance); + auto resistanceUnit = AppendNode(doc, electricalProp, "ResistanceUnit"); + SetNodeValue(doc, resistanceUnit, data.resistanceUnit); + auto indReactance = AppendNode(doc, electricalProp, "IndReactance"); + SetNodeValue(doc, indReactance, data.indReactance); + auto indReactanceUnit = AppendNode(doc, electricalProp, "IndReactanceUnit"); + SetNodeValue(doc, indReactanceUnit, data.indReactanceUnit); + auto capSusceptance = AppendNode(doc, electricalProp, "CapSusceptance"); + SetNodeValue(doc, capSusceptance, data.capSusceptance); + auto capSusceptanceUnit = AppendNode(doc, electricalProp, "CapSusceptanceUnit"); + SetNodeValue(doc, capSusceptanceUnit, data.capSusceptanceUnit); + auto lineSize = AppendNode(doc, electricalProp, "LineSize"); + SetNodeValue(doc, lineSize, data.lineSize); + auto useLinePower = AppendNode(doc, electricalProp, "UseLinePower"); + SetNodeValue(doc, useLinePower, data.useLinePower); + + auto fault = AppendNode(doc, electricalProp, "Fault"); + auto zeroResistance = AppendNode(doc, fault, "ZeroResistance"); + SetNodeValue(doc, zeroResistance, data.zeroResistance); + auto zeroIndReactance = AppendNode(doc, fault, "ZeroIndReactance"); + SetNodeValue(doc, zeroIndReactance, data.zeroIndReactance); + auto zeroCapSusceptance = AppendNode(doc, fault, "ZeroCapSusceptance"); + SetNodeValue(doc, zeroCapSusceptance, data.zeroCapSusceptance); + + auto switchingList = AppendNode(doc, electricalProp, "SwitchingList"); + SwitchingData swData = line->GetSwitchingData(); + for(int j = 0; j < (int)swData.swType.size(); j++) { + auto switching = AppendNode(doc, switchingList, "Switching"); + SetNodeAttribute(doc, switching, "ID", j); + auto swType = AppendNode(doc, switching, "Type"); + SetNodeValue(doc, swType, swData.swType[j]); + auto swTime = AppendNode(doc, switching, "Time"); + SetNodeValue(doc, swTime, swData.swTime[j]); + } + } //} + + //{ Load + auto loadsNode = AppendNode(doc, elementsNode, "LoadList"); + auto loadList = allElements.GetLoadList(); + for(int i = 0; i < (int)loadList.size(); i++) { + Load* load = loadList[i]; + auto loadNode = AppendNode(doc, loadsNode, "Load"); + auto cadProp = AppendNode(doc, loadNode, "CADProperties"); + auto position = AppendNode(doc, cadProp, "Position"); + auto posX = AppendNode(doc, position, "X"); + SetNodeValue(doc, posX, load->GetPosition().m_x); + auto posY = AppendNode(doc, position, "Y"); + SetNodeValue(doc, posY, load->GetPosition().m_y); + auto size = AppendNode(doc, cadProp, "Size"); + auto width = AppendNode(doc, size, "Width"); + SetNodeValue(doc, width, load->GetWidth()); + auto height = AppendNode(doc, size, "Height"); + SetNodeValue(doc, height, load->GetHeight()); + auto angle = AppendNode(doc, cadProp, "Angle"); + SetNodeValue(doc, angle, load->GetAngle()); + auto nodePos = AppendNode(doc, cadProp, "NodePosition"); + auto nodePosX = AppendNode(doc, nodePos, "X"); + SetNodeValue(doc, nodePosX, load->GetPointList()[0].m_x); + auto nodePosY = AppendNode(doc, nodePos, "Y"); + SetNodeValue(doc, nodePosY, load->GetPointList()[0].m_y); + auto parentID = AppendNode(doc, cadProp, "ParentID"); + Bus* parent = (Bus*)load->GetParentList()[0]; + if(parent) SetNodeValue(doc, parentID, parent->GetEletricalData().number); + + LoadElectricalData data = load->GetElectricalData(); + auto electricalProp = AppendNode(doc, loadNode, "ElectricalProperties"); + auto isOnline = AppendNode(doc, electricalProp, "IsOnline"); + SetNodeValue(doc, isOnline, load->IsOnline()); + auto name = AppendNode(doc, electricalProp, "Name"); + SetNodeValue(doc, name, data.name); + auto activePower = AppendNode(doc, electricalProp, "ActivePower"); + SetNodeValue(doc, activePower, data.activePower); + auto activePowerUnit = AppendNode(doc, electricalProp, "ActivePowerUnit"); + SetNodeValue(doc, activePowerUnit, data.activePowerUnit); + auto reactivePower = AppendNode(doc, electricalProp, "ReactivePower"); + SetNodeValue(doc, reactivePower, data.reactivePower); + auto reactivePowerUnit = AppendNode(doc, electricalProp, "ReactivePowerUnit"); + SetNodeValue(doc, reactivePowerUnit, data.reactivePowerUnit); + auto loadType = AppendNode(doc, electricalProp, "LoadType"); + SetNodeValue(doc, loadType, data.loadType); + + auto switchingList = AppendNode(doc, electricalProp, "SwitchingList"); + SwitchingData swData = load->GetSwitchingData(); + for(int j = 0; j < (int)swData.swType.size(); j++) { + auto switching = AppendNode(doc, switchingList, "Switching"); + SetNodeAttribute(doc, switching, "ID", j); + auto swType = AppendNode(doc, switching, "Type"); + SetNodeValue(doc, swType, swData.swType[j]); + auto swTime = AppendNode(doc, switching, "Time"); + SetNodeValue(doc, swTime, swData.swTime[j]); + } + } //} - //Save all the data - rapidxml::xml_node<>* testValues = AppendNode(doc, rootNode, "TestValues"); - rapidxml::xml_node<>* testDouble = AppendNode(doc, testValues, "TestDouble"); - SetNodeValue(doc, testDouble, 1.23456789123456789123456789); - rapidxml::xml_node<>* testInt = AppendNode(doc, testValues, "TestInt"); - SetNodeValue(doc, testInt, 123456789); - rapidxml::xml_node<>* testString = AppendNode(doc, testValues, "TestString"); - SetNodeValue(doc, testString, (wxString)"TESTE"); + //{ SyncGenerator + auto syncGeneratorsNode = AppendNode(doc, elementsNode, "SyncGeneratorList"); + auto syncGeneratorList = allElements.GetLoadList(); + for(int i = 0; i < (int)syncGeneratorList.size(); i++) { + SyncGenerator* syncGenerator = syncGeneratorList[i]; + auto syncGeneratorNode = AppendNode(doc, syncGeneratorsNode, "SyncGenerator"); + auto cadProp = AppendNode(doc, syncGeneratorNode, "CADProperties"); + auto position = AppendNode(doc, cadProp, "Position"); + auto posX = AppendNode(doc, position, "X"); + SetNodeValue(doc, posX, syncGenerator->GetPosition().m_x); + auto posY = AppendNode(doc, position, "Y"); + SetNodeValue(doc, posY, syncGenerator->GetPosition().m_y); + auto size = AppendNode(doc, cadProp, "Size"); + auto width = AppendNode(doc, size, "Width"); + SetNodeValue(doc, width, syncGenerator->GetWidth()); + auto height = AppendNode(doc, size, "Height"); + SetNodeValue(doc, height, syncGenerator->GetHeight()); + auto angle = AppendNode(doc, cadProp, "Angle"); + SetNodeValue(doc, angle, syncGenerator->GetAngle()); + auto nodePos = AppendNode(doc, cadProp, "NodePosition"); + auto nodePosX = AppendNode(doc, nodePos, "X"); + SetNodeValue(doc, nodePosX, syncGenerator->GetPointList()[0].m_x); + auto nodePosY = AppendNode(doc, nodePos, "Y"); + SetNodeValue(doc, nodePosY, syncGenerator->GetPointList()[0].m_y); + auto parentID = AppendNode(doc, cadProp, "ParentID"); + Bus* parent = (Bus*)syncGenerator->GetParentList()[0]; + if(parent) SetNodeValue(doc, parentID, parent->GetEletricalData().number); + + SyncGeneratorElectricalData data = syncGenerator->GetElectricalData(); + auto electricalProp = AppendNode(doc, syncGeneratorNode, "ElectricalProperties"); + auto isOnline = AppendNode(doc, electricalProp, "IsOnline"); + SetNodeValue(doc, isOnline, syncGenerator->IsOnline()); + auto name = AppendNode(doc, electricalProp, "Name"); + SetNodeValue(doc, name, data.name); + + /*wxString name = ""; + double nominalPower = 100.0; + ElectricalUnit nominalPowerUnit = UNIT_MVA; + double nominalVoltage = 13.8; + ElectricalUnit nominalVoltageUnit = UNIT_kV; + double activePower = 100.0; + ElectricalUnit activePowerUnit = UNIT_MW; + double reactivePower = 0.0; + ElectricalUnit reactivePowerUnit = UNIT_MVAr; + bool haveMaxReactive = false; + double maxReactive = 9999.0; + ElectricalUnit maxReactiveUnit = UNIT_MVAr; + bool haveMinReactive = false; + double minReactive = -9999.0; + ElectricalUnit minReactiveUnit = UNIT_MVAr; + bool useMachineBase = false; + + // Fault + double positiveResistance = 0.0; + double positiveReactance = 1.0; + double negativeResistance = 0.0; + double negativeReactance = 1.0; + double zeroResistance = 0.0; + double zeroReactance = 1.0; + double groundResistance = 0.0; + double groundReactance = 0.0; + bool groundNeutral = true; + // p.u. fault data + std::complex faultCurrent[3] = { std::complex(0.0, 0.0), std::complex(0.0, 0.0), + std::complex(0.0, 0.0) }; + + // Stability + bool plotSyncMachine = false; + double inertia = 0.0; + double damping = 0.0; + bool useAVR = false; + bool useSpeedGovernor = false; + + double armResistance = 0.0; + double potierReactance = 0.0; + double satFactor = 0.0; + + double syncXd = 0.0; + double syncXq = 0.0; + double transXd = 1.0; + double transXq = 0.0; + double transTd0 = 0.0; + double transTq0 = 0.0; + double subXd = 0.0; + double subXq = 0.0; + double subTd0 = 0.0; + double subTq0 = 0.0;*/ + + auto switchingList = AppendNode(doc, electricalProp, "SwitchingList"); + SwitchingData swData = syncGenerator->GetSwitchingData(); + for(int j = 0; j < (int)swData.swType.size(); j++) { + auto switching = AppendNode(doc, switchingList, "Switching"); + SetNodeAttribute(doc, switching, "ID", j); + auto swType = AppendNode(doc, switching, "Type"); + SetNodeValue(doc, swType, swData.swType[j]); + auto swTime = AppendNode(doc, switching, "Time"); + SetNodeValue(doc, swTime, swData.swTime[j]); + } + } //} std::ofstream writeXML(path.GetFullPath()); writeXML << doc; @@ -48,7 +485,10 @@ void FileHanding::SaveProject(wxFileName path) void FileHanding::OpenProject(wxFileName path) {} -rapidxml::xml_node<>* FileHanding::AppendNode(rapidxml::xml_document<>& doc, rapidxml::xml_node<>* parentNode, const char* name, rapidxml::node_type nodeType) +rapidxml::xml_node<>* FileHanding::AppendNode(rapidxml::xml_document<>& doc, + rapidxml::xml_node<>* parentNode, + const char* name, + rapidxml::node_type nodeType) { rapidxml::xml_node<>* node = doc.allocate_node(nodeType, name); parentNode->append_node(node); @@ -69,3 +509,28 @@ void FileHanding::SetNodeValue(rapidxml::xml_document<>& doc, rapidxml::xml_node { node->value(doc.allocate_string(wxString::FromCDouble(value, 13).mb_str())); } + +void FileHanding::SetNodeAttribute(rapidxml::xml_document<>& doc, + rapidxml::xml_node<>* node, + const char* atrName, + wxString value) +{ + node->append_attribute(doc.allocate_attribute(atrName, doc.allocate_string(value.mb_str()))); +} + +void FileHanding::SetNodeAttribute(rapidxml::xml_document<>& doc, + rapidxml::xml_node<>* node, + const char* atrName, + int value) +{ + node->append_attribute(doc.allocate_attribute(atrName, doc.allocate_string(wxString::Format("%d", value)))); +} + +void FileHanding::SetNodeAttribute(rapidxml::xml_document<>& doc, + rapidxml::xml_node<>* node, + const char* atrName, + double value) +{ + node->append_attribute( + doc.allocate_attribute(atrName, doc.allocate_string(wxString::FromCDouble(value, 13).mb_str()))); +} -- cgit From a235ce69803fb9b276ab682f9f15ddf30849372a Mon Sep 17 00:00:00 2001 From: Thales1330 Date: Tue, 13 Dec 2016 15:04:51 -0200 Subject: Save method implemented --- Project/FileHanding.cpp | 445 +++++++++++++++++++++++++++++++++++++++--------- 1 file changed, 362 insertions(+), 83 deletions(-) (limited to 'Project/FileHanding.cpp') diff --git a/Project/FileHanding.cpp b/Project/FileHanding.cpp index c7a8759..4071d4d 100644 --- a/Project/FileHanding.cpp +++ b/Project/FileHanding.cpp @@ -62,14 +62,12 @@ void FileHanding::SaveProject(wxFileName path) SetNodeValue(doc, name, data.name); auto nominalVoltage = AppendNode(doc, electricalProp, "NominalVoltage"); SetNodeValue(doc, nominalVoltage, data.nominalVoltage); - auto nominalVoltageUnit = AppendNode(doc, electricalProp, "NominalVoltageUnit"); - SetNodeValue(doc, nominalVoltageUnit, data.nominalVoltageUnit); + SetNodeAttribute(doc, nominalVoltage, "UnitID", data.nominalVoltageUnit); auto isVoltageControlled = AppendNode(doc, electricalProp, "IsVoltageControlled"); SetNodeValue(doc, isVoltageControlled, data.isVoltageControlled); auto controlledVoltage = AppendNode(doc, electricalProp, "ControlledVoltage"); SetNodeValue(doc, controlledVoltage, data.controlledVoltage); - auto controlledVoltageUnitChoice = AppendNode(doc, electricalProp, "ControlledVoltageUnitChoice"); - SetNodeValue(doc, controlledVoltageUnitChoice, data.controlledVoltageUnitChoice); + SetNodeAttribute(doc, controlledVoltage, "Choice", data.controlledVoltageUnitChoice); auto slackBus = AppendNode(doc, electricalProp, "SlackBus"); SetNodeValue(doc, slackBus, data.slackBus); @@ -109,6 +107,7 @@ void FileHanding::SaveProject(wxFileName path) for(int i = 0; i < (int)capacitorList.size(); i++) { Capacitor* capacitor = capacitorList[i]; auto capacitorNode = AppendNode(doc, capacitorsNode, "Capacitor"); + SetNodeAttribute(doc, capacitorNode, "ID", i); auto cadProp = AppendNode(doc, capacitorNode, "CADProperties"); auto position = AppendNode(doc, cadProp, "Position"); auto posX = AppendNode(doc, position, "X"); @@ -134,8 +133,7 @@ void FileHanding::SaveProject(wxFileName path) SetNodeValue(doc, name, data.name); auto reactivePower = AppendNode(doc, electricalProp, "ReactivePower"); SetNodeValue(doc, reactivePower, data.reactivePower); - auto reactivePowerUnit = AppendNode(doc, electricalProp, "ReactivePowerUnit"); - SetNodeValue(doc, reactivePowerUnit, data.reactivePowerUnit); + SetNodeAttribute(doc, reactivePower, "UnitID", data.reactivePowerUnit); auto switchingList = AppendNode(doc, electricalProp, "SwitchingList"); SwitchingData swData = capacitor->GetSwitchingData(); @@ -155,6 +153,7 @@ void FileHanding::SaveProject(wxFileName path) for(int i = 0; i < (int)indMotorList.size(); i++) { IndMotor* indMotor = indMotorList[i]; auto indMotorNode = AppendNode(doc, indMotorsNode, "IndMotor"); + SetNodeAttribute(doc, indMotorNode, "ID", i); auto cadProp = AppendNode(doc, indMotorNode, "CADProperties"); auto position = AppendNode(doc, cadProp, "Position"); auto posX = AppendNode(doc, position, "X"); @@ -179,12 +178,10 @@ void FileHanding::SaveProject(wxFileName path) SetNodeValue(doc, name, data.name); auto activePower = AppendNode(doc, electricalProp, "ActivePower"); SetNodeValue(doc, activePower, data.activePower); - auto activePowerUnit = AppendNode(doc, electricalProp, "ActivePowerUnit"); - SetNodeValue(doc, activePowerUnit, data.activePowerUnit); + SetNodeAttribute(doc, activePower, "UnitID", data.activePowerUnit); auto reactivePower = AppendNode(doc, electricalProp, "ReactivePower"); SetNodeValue(doc, reactivePower, data.reactivePower); - auto reactivePowerUnit = AppendNode(doc, electricalProp, "ReactivePowerUnit"); - SetNodeValue(doc, reactivePowerUnit, data.reactivePowerUnit); + SetNodeAttribute(doc, reactivePower, "UnitID", data.reactivePowerUnit); } //} //{ Inductor @@ -193,6 +190,7 @@ void FileHanding::SaveProject(wxFileName path) for(int i = 0; i < (int)inductorList.size(); i++) { Inductor* inductor = inductorList[i]; auto inductorNode = AppendNode(doc, inductorsNode, "Inductor"); + SetNodeAttribute(doc, inductorNode, "ID", i); auto cadProp = AppendNode(doc, inductorNode, "CADProperties"); auto position = AppendNode(doc, cadProp, "Position"); auto posX = AppendNode(doc, position, "X"); @@ -223,8 +221,7 @@ void FileHanding::SaveProject(wxFileName path) SetNodeValue(doc, name, data.name); auto reactivePower = AppendNode(doc, electricalProp, "ReactivePower"); SetNodeValue(doc, reactivePower, data.reactivePower); - auto reactivePowerUnit = AppendNode(doc, electricalProp, "ReactivePowerUnit"); - SetNodeValue(doc, reactivePowerUnit, data.reactivePowerUnit); + SetNodeAttribute(doc, reactivePower, "UnitID", data.reactivePowerUnit); auto switchingList = AppendNode(doc, electricalProp, "SwitchingList"); SwitchingData swData = inductor->GetSwitchingData(); @@ -244,6 +241,7 @@ void FileHanding::SaveProject(wxFileName path) for(int i = 0; i < (int)lineList.size(); i++) { Line* line = lineList[i]; auto lineNode = AppendNode(doc, linesNode, "Line"); + SetNodeAttribute(doc, lineNode, "ID", i); auto cadProp = AppendNode(doc, lineNode, "CADProperties"); auto nodeList = AppendNode(doc, cadProp, "NodeList"); auto ptList = line->GetPointList(); @@ -278,29 +276,24 @@ void FileHanding::SaveProject(wxFileName path) SetNodeValue(doc, name, data.name); auto nominalVoltage = AppendNode(doc, electricalProp, "NominalVoltage"); SetNodeValue(doc, nominalVoltage, data.nominalVoltage); - auto nominalVoltageUnit = AppendNode(doc, electricalProp, "NominalVoltageUnit"); - SetNodeValue(doc, nominalVoltageUnit, data.nominalVoltageUnit); + SetNodeAttribute(doc, nominalVoltage, "UnitID", data.nominalVoltageUnit); auto nominalPower = AppendNode(doc, electricalProp, "NominalPower"); SetNodeValue(doc, nominalPower, data.nominalPower); - auto nominalPowerUnit = AppendNode(doc, electricalProp, "NominalPowerUnit"); - SetNodeValue(doc, nominalPowerUnit, data.nominalPowerUnit); + SetNodeAttribute(doc, nominalPower, "UnitID", data.nominalPowerUnit); auto resistance = AppendNode(doc, electricalProp, "Resistance"); SetNodeValue(doc, resistance, data.resistance); - auto resistanceUnit = AppendNode(doc, electricalProp, "ResistanceUnit"); - SetNodeValue(doc, resistanceUnit, data.resistanceUnit); + SetNodeAttribute(doc, resistance, "UnitID", data.resistanceUnit); auto indReactance = AppendNode(doc, electricalProp, "IndReactance"); SetNodeValue(doc, indReactance, data.indReactance); - auto indReactanceUnit = AppendNode(doc, electricalProp, "IndReactanceUnit"); - SetNodeValue(doc, indReactanceUnit, data.indReactanceUnit); + SetNodeAttribute(doc, indReactance, "UnitID", data.indReactanceUnit); auto capSusceptance = AppendNode(doc, electricalProp, "CapSusceptance"); SetNodeValue(doc, capSusceptance, data.capSusceptance); - auto capSusceptanceUnit = AppendNode(doc, electricalProp, "CapSusceptanceUnit"); - SetNodeValue(doc, capSusceptanceUnit, data.capSusceptanceUnit); + SetNodeAttribute(doc, capSusceptance, "UnitID", data.capSusceptanceUnit); auto lineSize = AppendNode(doc, electricalProp, "LineSize"); SetNodeValue(doc, lineSize, data.lineSize); auto useLinePower = AppendNode(doc, electricalProp, "UseLinePower"); SetNodeValue(doc, useLinePower, data.useLinePower); - + auto fault = AppendNode(doc, electricalProp, "Fault"); auto zeroResistance = AppendNode(doc, fault, "ZeroResistance"); SetNodeValue(doc, zeroResistance, data.zeroResistance); @@ -320,13 +313,14 @@ void FileHanding::SaveProject(wxFileName path) SetNodeValue(doc, swTime, swData.swTime[j]); } } //} - + //{ Load auto loadsNode = AppendNode(doc, elementsNode, "LoadList"); auto loadList = allElements.GetLoadList(); for(int i = 0; i < (int)loadList.size(); i++) { Load* load = loadList[i]; auto loadNode = AppendNode(doc, loadsNode, "Load"); + SetNodeAttribute(doc, loadNode, "ID", i); auto cadProp = AppendNode(doc, loadNode, "CADProperties"); auto position = AppendNode(doc, cadProp, "Position"); auto posX = AppendNode(doc, position, "X"); @@ -357,12 +351,10 @@ void FileHanding::SaveProject(wxFileName path) SetNodeValue(doc, name, data.name); auto activePower = AppendNode(doc, electricalProp, "ActivePower"); SetNodeValue(doc, activePower, data.activePower); - auto activePowerUnit = AppendNode(doc, electricalProp, "ActivePowerUnit"); - SetNodeValue(doc, activePowerUnit, data.activePowerUnit); + SetNodeAttribute(doc, activePower, "UnitID", data.activePowerUnit); auto reactivePower = AppendNode(doc, electricalProp, "ReactivePower"); SetNodeValue(doc, reactivePower, data.reactivePower); - auto reactivePowerUnit = AppendNode(doc, electricalProp, "ReactivePowerUnit"); - SetNodeValue(doc, reactivePowerUnit, data.reactivePowerUnit); + SetNodeAttribute(doc, reactivePower, "UnitID", data.reactivePowerUnit); auto loadType = AppendNode(doc, electricalProp, "LoadType"); SetNodeValue(doc, loadType, data.loadType); @@ -377,13 +369,14 @@ void FileHanding::SaveProject(wxFileName path) SetNodeValue(doc, swTime, swData.swTime[j]); } } //} - + //{ SyncGenerator auto syncGeneratorsNode = AppendNode(doc, elementsNode, "SyncGeneratorList"); - auto syncGeneratorList = allElements.GetLoadList(); + auto syncGeneratorList = allElements.GetSyncGeneratorList(); for(int i = 0; i < (int)syncGeneratorList.size(); i++) { SyncGenerator* syncGenerator = syncGeneratorList[i]; auto syncGeneratorNode = AppendNode(doc, syncGeneratorsNode, "SyncGenerator"); + SetNodeAttribute(doc, syncGeneratorNode, "ID", i); auto cadProp = AppendNode(doc, syncGeneratorNode, "CADProperties"); auto position = AppendNode(doc, cadProp, "Position"); auto posX = AppendNode(doc, position, "X"); @@ -412,59 +405,84 @@ void FileHanding::SaveProject(wxFileName path) SetNodeValue(doc, isOnline, syncGenerator->IsOnline()); auto name = AppendNode(doc, electricalProp, "Name"); SetNodeValue(doc, name, data.name); - - /*wxString name = ""; - double nominalPower = 100.0; - ElectricalUnit nominalPowerUnit = UNIT_MVA; - double nominalVoltage = 13.8; - ElectricalUnit nominalVoltageUnit = UNIT_kV; - double activePower = 100.0; - ElectricalUnit activePowerUnit = UNIT_MW; - double reactivePower = 0.0; - ElectricalUnit reactivePowerUnit = UNIT_MVAr; - bool haveMaxReactive = false; - double maxReactive = 9999.0; - ElectricalUnit maxReactiveUnit = UNIT_MVAr; - bool haveMinReactive = false; - double minReactive = -9999.0; - ElectricalUnit minReactiveUnit = UNIT_MVAr; - bool useMachineBase = false; - - // Fault - double positiveResistance = 0.0; - double positiveReactance = 1.0; - double negativeResistance = 0.0; - double negativeReactance = 1.0; - double zeroResistance = 0.0; - double zeroReactance = 1.0; - double groundResistance = 0.0; - double groundReactance = 0.0; - bool groundNeutral = true; - // p.u. fault data - std::complex faultCurrent[3] = { std::complex(0.0, 0.0), std::complex(0.0, 0.0), - std::complex(0.0, 0.0) }; - - // Stability - bool plotSyncMachine = false; - double inertia = 0.0; - double damping = 0.0; - bool useAVR = false; - bool useSpeedGovernor = false; - - double armResistance = 0.0; - double potierReactance = 0.0; - double satFactor = 0.0; - - double syncXd = 0.0; - double syncXq = 0.0; - double transXd = 1.0; - double transXq = 0.0; - double transTd0 = 0.0; - double transTq0 = 0.0; - double subXd = 0.0; - double subXq = 0.0; - double subTd0 = 0.0; - double subTq0 = 0.0;*/ + auto nominalPower = AppendNode(doc, electricalProp, "NominalPower"); + SetNodeValue(doc, nominalPower, data.nominalPower); + SetNodeAttribute(doc, nominalPower, "UnitID", data.nominalPowerUnit); + auto nominalVoltage = AppendNode(doc, electricalProp, "NominalVoltage"); + SetNodeValue(doc, nominalVoltage, data.nominalVoltage); + SetNodeAttribute(doc, nominalVoltage, "UnitID", data.nominalVoltageUnit); + auto activePower = AppendNode(doc, electricalProp, "ActivePower"); + SetNodeValue(doc, activePower, data.activePower); + SetNodeAttribute(doc, activePower, "UnitID", data.activePowerUnit); + auto reactivePower = AppendNode(doc, electricalProp, "ReactivePower"); + SetNodeValue(doc, reactivePower, data.reactivePower); + SetNodeAttribute(doc, reactivePower, "UnitID", data.reactivePowerUnit); + auto haveMaxReactive = AppendNode(doc, electricalProp, "HaveMaxReactive"); + SetNodeValue(doc, haveMaxReactive, data.haveMaxReactive); + auto maxReactive = AppendNode(doc, electricalProp, "MaxReactive"); + SetNodeValue(doc, maxReactive, data.maxReactive); + SetNodeAttribute(doc, maxReactive, "UnitID", data.maxReactiveUnit); + auto haveMinReactive = AppendNode(doc, electricalProp, "HaveMinReactive"); + SetNodeValue(doc, haveMinReactive, data.haveMinReactive); + auto minReactive = AppendNode(doc, electricalProp, "MinReactive"); + SetNodeValue(doc, minReactive, data.minReactive); + SetNodeAttribute(doc, minReactive, "UnitID", data.minReactiveUnit); + auto useMachineBase = AppendNode(doc, electricalProp, "UseMachineBase"); + SetNodeValue(doc, useMachineBase, data.useMachineBase); + + auto fault = AppendNode(doc, electricalProp, "Fault"); + auto positiveResistance = AppendNode(doc, fault, "PositiveResistance"); + SetNodeValue(doc, positiveResistance, data.positiveResistance); + auto positiveReactance = AppendNode(doc, fault, "PositiveReactance"); + SetNodeValue(doc, positiveReactance, data.positiveReactance); + auto negativeResistance = AppendNode(doc, fault, "NegativeResistance"); + SetNodeValue(doc, negativeResistance, data.negativeResistance); + auto negativeReactance = AppendNode(doc, fault, "NegativeReactance"); + SetNodeValue(doc, negativeReactance, data.negativeReactance); + auto zeroResistance = AppendNode(doc, fault, "ZeroResistance"); + SetNodeValue(doc, zeroResistance, data.zeroResistance); + auto zeroReactance = AppendNode(doc, fault, "ZeroReactance"); + SetNodeValue(doc, zeroReactance, data.zeroReactance); + auto groundNeutral = AppendNode(doc, fault, "GroundNeutral"); + SetNodeValue(doc, groundNeutral, data.groundNeutral); + + auto stability = AppendNode(doc, electricalProp, "Stability"); + auto plotSyncMachine = AppendNode(doc, stability, "PlotSyncMachine"); + SetNodeValue(doc, plotSyncMachine, data.plotSyncMachine); + auto inertia = AppendNode(doc, stability, "Inertia"); + SetNodeValue(doc, inertia, data.inertia); + auto damping = AppendNode(doc, stability, "Damping"); + SetNodeValue(doc, damping, data.damping); + auto useAVR = AppendNode(doc, stability, "UseAVR"); + SetNodeValue(doc, useAVR, data.useAVR); + auto useSpeedGovernor = AppendNode(doc, stability, "UseSpeedGovernor"); + SetNodeValue(doc, useSpeedGovernor, data.useSpeedGovernor); + auto armResistance = AppendNode(doc, stability, "ArmResistance"); + SetNodeValue(doc, armResistance, data.armResistance); + auto potierReactance = AppendNode(doc, stability, "PotierReactance"); + SetNodeValue(doc, potierReactance, data.potierReactance); + auto satFactor = AppendNode(doc, stability, "SatFactor"); + SetNodeValue(doc, satFactor, data.satFactor); + auto syncXd = AppendNode(doc, stability, "SyncXd"); + SetNodeValue(doc, syncXd, data.syncXd); + auto syncXq = AppendNode(doc, stability, "SyncXq"); + SetNodeValue(doc, syncXq, data.syncXq); + auto transXd = AppendNode(doc, stability, "TransXd"); + SetNodeValue(doc, transXd, data.transXd); + auto transXq = AppendNode(doc, stability, "TransXq"); + SetNodeValue(doc, transXq, data.transXq); + auto transTd0 = AppendNode(doc, stability, "TransTd0"); + SetNodeValue(doc, transTd0, data.transTd0); + auto transTq0 = AppendNode(doc, stability, "TransTq0"); + SetNodeValue(doc, transTq0, data.transTq0); + auto subXd = AppendNode(doc, stability, "SubXd"); + SetNodeValue(doc, subXd, data.subXd); + auto subXq = AppendNode(doc, stability, "SubXq"); + SetNodeValue(doc, subXq, data.subXq); + auto subTd0 = AppendNode(doc, stability, "SubTd0"); + SetNodeValue(doc, subTd0, data.subTd0); + auto subTq0 = AppendNode(doc, stability, "SubTq0"); + SetNodeValue(doc, subTq0, data.subTq0); auto switchingList = AppendNode(doc, electricalProp, "SwitchingList"); SwitchingData swData = syncGenerator->GetSwitchingData(); @@ -478,6 +496,267 @@ void FileHanding::SaveProject(wxFileName path) } } //} + //{ SyncMotor + auto syncMotorsNode = AppendNode(doc, elementsNode, "SyncMotorList"); + auto syncMotorList = allElements.GetSyncMotorList(); + for(int i = 0; i < (int)syncMotorList.size(); i++) { + SyncMotor* syncMotor = syncMotorList[i]; + auto syncMotorNode = AppendNode(doc, syncMotorsNode, "SyncMotor"); + SetNodeAttribute(doc, syncMotorNode, "ID", i); + auto cadProp = AppendNode(doc, syncMotorNode, "CADProperties"); + auto position = AppendNode(doc, cadProp, "Position"); + auto posX = AppendNode(doc, position, "X"); + SetNodeValue(doc, posX, syncMotor->GetPosition().m_x); + auto posY = AppendNode(doc, position, "Y"); + SetNodeValue(doc, posY, syncMotor->GetPosition().m_y); + auto size = AppendNode(doc, cadProp, "Size"); + auto width = AppendNode(doc, size, "Width"); + SetNodeValue(doc, width, syncMotor->GetWidth()); + auto height = AppendNode(doc, size, "Height"); + SetNodeValue(doc, height, syncMotor->GetHeight()); + auto angle = AppendNode(doc, cadProp, "Angle"); + SetNodeValue(doc, angle, syncMotor->GetAngle()); + auto nodePos = AppendNode(doc, cadProp, "NodePosition"); + auto nodePosX = AppendNode(doc, nodePos, "X"); + SetNodeValue(doc, nodePosX, syncMotor->GetPointList()[0].m_x); + auto nodePosY = AppendNode(doc, nodePos, "Y"); + SetNodeValue(doc, nodePosY, syncMotor->GetPointList()[0].m_y); + auto parentID = AppendNode(doc, cadProp, "ParentID"); + Bus* parent = (Bus*)syncMotor->GetParentList()[0]; + if(parent) SetNodeValue(doc, parentID, parent->GetEletricalData().number); + + SyncMotorElectricalData data = syncMotor->GetElectricalData(); + auto electricalProp = AppendNode(doc, syncMotorNode, "ElectricalProperties"); + auto isOnline = AppendNode(doc, electricalProp, "IsOnline"); + SetNodeValue(doc, isOnline, syncMotor->IsOnline()); + auto name = AppendNode(doc, electricalProp, "Name"); + SetNodeValue(doc, name, data.name); + auto nominalPower = AppendNode(doc, electricalProp, "NominalPower"); + SetNodeValue(doc, nominalPower, data.nominalPower); + SetNodeAttribute(doc, nominalPower, "UnitID", data.nominalPowerUnit); + // auto nominalVoltage = AppendNode(doc, electricalProp, "NominalVoltage"); + // SetNodeValue(doc, nominalVoltage, data.nominalVoltage); + // SetNodeAttribute(doc, nominalVoltage, "UnitID", data.nominalVoltageUnit); + auto activePower = AppendNode(doc, electricalProp, "ActivePower"); + SetNodeValue(doc, activePower, data.activePower); + SetNodeAttribute(doc, activePower, "UnitID", data.activePowerUnit); + auto reactivePower = AppendNode(doc, electricalProp, "ReactivePower"); + SetNodeValue(doc, reactivePower, data.reactivePower); + SetNodeAttribute(doc, reactivePower, "UnitID", data.reactivePowerUnit); + auto haveMaxReactive = AppendNode(doc, electricalProp, "HaveMaxReactive"); + SetNodeValue(doc, haveMaxReactive, data.haveMaxReactive); + auto maxReactive = AppendNode(doc, electricalProp, "MaxReactive"); + SetNodeValue(doc, maxReactive, data.maxReactive); + SetNodeAttribute(doc, maxReactive, "UnitID", data.maxReactiveUnit); + auto haveMinReactive = AppendNode(doc, electricalProp, "HaveMinReactive"); + SetNodeValue(doc, haveMinReactive, data.haveMinReactive); + auto minReactive = AppendNode(doc, electricalProp, "MinReactive"); + SetNodeValue(doc, minReactive, data.minReactive); + SetNodeAttribute(doc, minReactive, "UnitID", data.minReactiveUnit); + auto useMachineBase = AppendNode(doc, electricalProp, "UseMachineBase"); + SetNodeValue(doc, useMachineBase, data.useMachineBase); + + auto fault = AppendNode(doc, electricalProp, "Fault"); + auto positiveResistance = AppendNode(doc, fault, "PositiveResistance"); + SetNodeValue(doc, positiveResistance, data.positiveResistance); + auto positiveReactance = AppendNode(doc, fault, "PositiveReactance"); + SetNodeValue(doc, positiveReactance, data.positiveReactance); + auto negativeResistance = AppendNode(doc, fault, "NegativeResistance"); + SetNodeValue(doc, negativeResistance, data.negativeResistance); + auto negativeReactance = AppendNode(doc, fault, "NegativeReactance"); + SetNodeValue(doc, negativeReactance, data.negativeReactance); + auto zeroResistance = AppendNode(doc, fault, "ZeroResistance"); + SetNodeValue(doc, zeroResistance, data.zeroResistance); + auto zeroReactance = AppendNode(doc, fault, "ZeroReactance"); + SetNodeValue(doc, zeroReactance, data.zeroReactance); + auto groundNeutral = AppendNode(doc, fault, "GroundNeutral"); + SetNodeValue(doc, groundNeutral, data.groundNeutral); + + // To future use... + /*auto stability = AppendNode(doc, electricalProp, "Stability"); + auto plotSyncMachine = AppendNode(doc, stability, "PlotSyncMotor"); + SetNodeValue(doc, plotSyncMachine, data.plotSyncMachine); + auto inertia = AppendNode(doc, stability, "Inertia"); + SetNodeValue(doc, inertia, data.inertia); + auto damping = AppendNode(doc, stability, "Damping"); + SetNodeValue(doc, damping, data.damping); + auto useAVR = AppendNode(doc, stability, "UseAVR"); + SetNodeValue(doc, useAVR, data.useAVR); + auto armResistance = AppendNode(doc, stability, "ArmResistance"); + SetNodeValue(doc, armResistance, data.armResistance); + auto potierReactance = AppendNode(doc, stability, "PotierReactance"); + SetNodeValue(doc, potierReactance, data.potierReactance); + auto satFactor = AppendNode(doc, stability, "SatFactor"); + SetNodeValue(doc, satFactor, data.satFactor); + auto syncXd = AppendNode(doc, stability, "SyncXd"); + SetNodeValue(doc, syncXd, data.syncXd); + auto syncXq = AppendNode(doc, stability, "SyncXq"); + SetNodeValue(doc, syncXq, data.syncXq); + auto transXd = AppendNode(doc, stability, "TransXd"); + SetNodeValue(doc, transXd, data.transXd); + auto transXq = AppendNode(doc, stability, "TransXq"); + SetNodeValue(doc, transXq, data.transXq); + auto transTd0 = AppendNode(doc, stability, "TransTd0"); + SetNodeValue(doc, transTd0, data.transTd0); + auto transTq0 = AppendNode(doc, stability, "TransTq0"); + SetNodeValue(doc, transTq0, data.transTq0); + auto subXd = AppendNode(doc, stability, "SubXd"); + SetNodeValue(doc, subXd, data.subXd); + auto subXq = AppendNode(doc, stability, "SubXq"); + SetNodeValue(doc, subXq, data.subXq); + auto subTd0 = AppendNode(doc, stability, "SubTd0"); + SetNodeValue(doc, subTd0, data.subTd0); + auto subTq0 = AppendNode(doc, stability, "SubTq0"); + SetNodeValue(doc, subTq0, data.subTq0); + + auto switchingList = AppendNode(doc, electricalProp, "SwitchingList"); + SwitchingData swData = syncGenerator->GetSwitchingData(); + for(int j = 0; j < (int)swData.swType.size(); j++) { + auto switching = AppendNode(doc, switchingList, "Switching"); + SetNodeAttribute(doc, switching, "ID", j); + auto swType = AppendNode(doc, switching, "Type"); + SetNodeValue(doc, swType, swData.swType[j]); + auto swTime = AppendNode(doc, switching, "Time"); + SetNodeValue(doc, swTime, swData.swTime[j]); + }*/ + } //} + + //{ Transfomer + auto transformersNode = AppendNode(doc, elementsNode, "TransformerList"); + auto transformerList = allElements.GetTransformerList(); + for(int i = 0; i < (int)transformerList.size(); i++) { + Transformer* transfomer = transformerList[i]; + auto transformerNode = AppendNode(doc, transformersNode, "Transfomer"); + SetNodeAttribute(doc, transformerNode, "ID", i); + auto cadProp = AppendNode(doc, transformerNode, "CADProperties"); + auto position = AppendNode(doc, cadProp, "Position"); + auto posX = AppendNode(doc, position, "X"); + SetNodeValue(doc, posX, transfomer->GetPosition().m_x); + auto posY = AppendNode(doc, position, "Y"); + SetNodeValue(doc, posY, transfomer->GetPosition().m_y); + auto size = AppendNode(doc, cadProp, "Size"); + auto width = AppendNode(doc, size, "Width"); + SetNodeValue(doc, width, transfomer->GetWidth()); + auto height = AppendNode(doc, size, "Height"); + SetNodeValue(doc, height, transfomer->GetHeight()); + auto angle = AppendNode(doc, cadProp, "Angle"); + SetNodeValue(doc, angle, transfomer->GetAngle()); + auto nodeList = AppendNode(doc, cadProp, "NodeList"); + auto nodePos1 = AppendNode(doc, nodeList, "Node"); + SetNodeAttribute(doc, nodePos1, "ID", 0); + auto nodePosX1 = AppendNode(doc, nodePos1, "X"); + SetNodeValue(doc, nodePosX1, transfomer->GetPointList()[0].m_x); + auto nodePosY1 = AppendNode(doc, nodePos1, "Y"); + SetNodeValue(doc, nodePosY1, transfomer->GetPointList()[0].m_y); + auto nodePos2 = AppendNode(doc, nodeList, "Node"); + SetNodeAttribute(doc, nodePos2, "ID", 1); + auto nodePosX2 = AppendNode(doc, nodePos2, "X"); + SetNodeValue(doc, nodePosX2, transfomer->GetPointList()[transfomer->GetPointList().size() - 1].m_x); + auto nodePosY2 = AppendNode(doc, nodePos2, "Y"); + SetNodeValue(doc, nodePosY2, transfomer->GetPointList()[transfomer->GetPointList().size() - 1].m_y); + + auto parentIDList = AppendNode(doc, cadProp, "ParentIDList"); + for(int j = 0; j < (int)transfomer->GetParentList().size(); j++) { + Bus* parent = (Bus*)transfomer->GetParentList()[j]; + if(parent) { + auto parentID = AppendNode(doc, parentIDList, "ParentID"); + SetNodeAttribute(doc, parentID, "ID", j); + SetNodeValue(doc, parentID, parent->GetEletricalData().number); + } + } + + TransformerElectricalData data = transfomer->GetElectricalData(); + auto electricalProp = AppendNode(doc, transformerNode, "ElectricalProperties"); + auto isOnline = AppendNode(doc, electricalProp, "IsOnline"); + SetNodeValue(doc, isOnline, transfomer->IsOnline()); + auto name = AppendNode(doc, electricalProp, "Name"); + SetNodeValue(doc, name, data.name); + auto primaryNominalVoltage = AppendNode(doc, electricalProp, "PrimaryNominalVoltage"); + SetNodeValue(doc, primaryNominalVoltage, data.primaryNominalVoltage); + SetNodeAttribute(doc, primaryNominalVoltage, "UnitID", data.primaryNominalVoltageUnit); + auto secondaryNominalVoltage = AppendNode(doc, electricalProp, "SecondaryNominalVoltage"); + SetNodeValue(doc, secondaryNominalVoltage, data.secondaryNominalVoltage); + SetNodeAttribute(doc, secondaryNominalVoltage, "UnitID", data.secondaryNominalVoltageUnit); + auto nominalPower = AppendNode(doc, electricalProp, "NominalPower"); + SetNodeValue(doc, nominalPower, data.nominalPower); + SetNodeAttribute(doc, nominalPower, "UnitID", data.nominalPowerUnit); + auto resistance = AppendNode(doc, electricalProp, "Resistance"); + SetNodeValue(doc, resistance, data.resistance); + SetNodeAttribute(doc, resistance, "UnitID", data.resistanceUnit); + auto indReactance = AppendNode(doc, electricalProp, "IndReactance"); + SetNodeValue(doc, indReactance, data.indReactance); + SetNodeAttribute(doc, indReactance, "UnitID", data.indReactanceUnit); + auto connection = AppendNode(doc, electricalProp, "Connection"); + SetNodeValue(doc, connection, data.connection); + auto turnsRatio = AppendNode(doc, electricalProp, "TurnsRatio"); + SetNodeValue(doc, turnsRatio, data.turnsRatio); + auto phaseShift = AppendNode(doc, electricalProp, "PhaseShift"); + SetNodeValue(doc, phaseShift, data.phaseShift); + auto useTransformerPower = AppendNode(doc, electricalProp, "UseTransfomerPower"); + SetNodeValue(doc, useTransformerPower, data.useTransformerPower); + + auto fault = AppendNode(doc, electricalProp, "Fault"); + auto zeroResistance = AppendNode(doc, fault, "ZeroResistance"); + SetNodeValue(doc, zeroResistance, data.zeroResistance); + auto zeroIndReactance = AppendNode(doc, fault, "ZeroIndReactance"); + SetNodeValue(doc, zeroIndReactance, data.zeroIndReactance); + auto primaryGrndResistance = AppendNode(doc, fault, "PrimaryGrndResistance"); + SetNodeValue(doc, primaryGrndResistance, data.primaryGrndResistance); + auto primaryGrndReactance = AppendNode(doc, fault, "PrimaryGrndReactance"); + SetNodeValue(doc, primaryGrndReactance, data.primaryGrndReactance); + auto secondaryGrndResistance = AppendNode(doc, fault, "SecondaryGrndResistance"); + SetNodeValue(doc, secondaryGrndResistance, data.secondaryGrndResistance); + auto secondaryGrndReactance = AppendNode(doc, fault, "SecondaryGrndReactance"); + SetNodeValue(doc, secondaryGrndReactance, data.secondaryGrndReactance); + + auto switchingList = AppendNode(doc, electricalProp, "SwitchingList"); + SwitchingData swData = transfomer->GetSwitchingData(); + for(int j = 0; j < (int)swData.swType.size(); j++) { + auto switching = AppendNode(doc, switchingList, "Switching"); + SetNodeAttribute(doc, switching, "ID", j); + auto swType = AppendNode(doc, switching, "Type"); + SetNodeValue(doc, swType, swData.swType[j]); + auto swTime = AppendNode(doc, switching, "Time"); + SetNodeValue(doc, swTime, swData.swTime[j]); + } + } //} + + //{ Text + auto textsNode = AppendNode(doc, elementsNode, "TextList"); + auto textList = m_workspace->GetTextList(); + for(int i = 0; i < (int)textList.size(); i++) { + Text* text = textList[i]; + auto textNode = AppendNode(doc, textsNode, "Text"); + SetNodeAttribute(doc, textNode, "ID", i); + auto cadProp = AppendNode(doc, textNode, "CADProperties"); + auto position = AppendNode(doc, cadProp, "Position"); + auto posX = AppendNode(doc, position, "X"); + SetNodeValue(doc, posX, text->GetPosition().m_x); + auto posY = AppendNode(doc, position, "Y"); + SetNodeValue(doc, posY, text->GetPosition().m_y); + auto size = AppendNode(doc, cadProp, "Size"); + auto width = AppendNode(doc, size, "Width"); + SetNodeValue(doc, width, text->GetWidth()); + auto height = AppendNode(doc, size, "Height"); + SetNodeValue(doc, height, text->GetHeight()); + auto angle = AppendNode(doc, cadProp, "Angle"); + SetNodeValue(doc, angle, text->GetAngle()); + auto textProperties = AppendNode(doc, textNode, "TextProperties"); + auto elementType = AppendNode(doc, textProperties, "ElementType"); + SetNodeValue(doc, elementType, text->GetElementType()); + auto elementNumber = AppendNode(doc, textProperties, "ElementNumber"); + SetNodeValue(doc, elementNumber, text->GetElementNumber()); + auto dataType = AppendNode(doc, textProperties, "DataType"); + SetNodeValue(doc, dataType, text->GetDataType()); + auto dataUnit = AppendNode(doc, textProperties, "DataUnit"); + SetNodeValue(doc, dataUnit, text->GetUnit()); + auto direction = AppendNode(doc, textProperties, "Direction"); + SetNodeValue(doc, direction, text->GetDirection()); + auto decimalPlaces = AppendNode(doc, textProperties, "DecimalPlaces"); + SetNodeValue(doc, decimalPlaces, text->GetDecimalPlaces()); + } + //} + std::ofstream writeXML(path.GetFullPath()); writeXML << doc; writeXML.close(); -- cgit From e86a20525e9838f4b3962eb267ea51dce7e8fb77 Mon Sep 17 00:00:00 2001 From: Thales1330 Date: Tue, 13 Dec 2016 21:38:03 -0200 Subject: Bus open implemented, capacitor buggy --- Project/FileHanding.cpp | 177 +++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 175 insertions(+), 2 deletions(-) (limited to 'Project/FileHanding.cpp') diff --git a/Project/FileHanding.cpp b/Project/FileHanding.cpp index 4071d4d..1586aa6 100644 --- a/Project/FileHanding.cpp +++ b/Project/FileHanding.cpp @@ -121,6 +121,11 @@ void FileHanding::SaveProject(wxFileName path) SetNodeValue(doc, height, capacitor->GetHeight()); auto angle = AppendNode(doc, cadProp, "Angle"); SetNodeValue(doc, angle, capacitor->GetAngle()); + auto nodePos = AppendNode(doc, cadProp, "NodePosition"); + auto nodePosX = AppendNode(doc, nodePos, "X"); + SetNodeValue(doc, nodePosX, capacitor->GetPointList()[0].m_x); + auto nodePosY = AppendNode(doc, nodePos, "Y"); + SetNodeValue(doc, nodePosY, capacitor->GetPointList()[0].m_y); auto parentID = AppendNode(doc, cadProp, "ParentID"); Bus* parent = (Bus*)capacitor->GetParentList()[0]; if(parent) SetNodeValue(doc, parentID, parent->GetEletricalData().number); @@ -167,6 +172,11 @@ void FileHanding::SaveProject(wxFileName path) SetNodeValue(doc, height, indMotor->GetHeight()); auto angle = AppendNode(doc, cadProp, "Angle"); SetNodeValue(doc, angle, indMotor->GetAngle()); + auto nodePos = AppendNode(doc, cadProp, "NodePosition"); + auto nodePosX = AppendNode(doc, nodePos, "X"); + SetNodeValue(doc, nodePosX, indMotor->GetPointList()[0].m_x); + auto nodePosY = AppendNode(doc, nodePos, "Y"); + SetNodeValue(doc, nodePosY, indMotor->GetPointList()[0].m_y); auto parentID = AppendNode(doc, cadProp, "ParentID"); SetNodeValue(doc, parentID, ((Bus*)indMotor->GetParentList()[0])->GetEletricalData().number); @@ -720,7 +730,7 @@ void FileHanding::SaveProject(wxFileName path) SetNodeValue(doc, swTime, swData.swTime[j]); } } //} - + //{ Text auto textsNode = AppendNode(doc, elementsNode, "TextList"); auto textList = m_workspace->GetTextList(); @@ -762,7 +772,137 @@ void FileHanding::SaveProject(wxFileName path) writeXML.close(); } -void FileHanding::OpenProject(wxFileName path) {} +bool FileHanding::OpenProject(wxFileName path) +{ + rapidxml::xml_document<> doc; + rapidxml::file<> xmlFile(path.GetFullPath()); + + doc.parse<0>(xmlFile.data()); + + auto projectNode = doc.first_node("Project"); + if(!projectNode) return false; + auto nameNode = projectNode->first_node("Name"); + if(!nameNode) return false; + m_workspace->SetName(nameNode->value()); + + // Open elements + auto elementsNode = projectNode->first_node("Elements"); + if(!elementsNode) return false; + std::vector elementList; + std::vector busList; // To fill parents. + + //{ Bus + auto busListNode = elementsNode->first_node("BusList"); + if(!busListNode) return false; + auto busNode = busListNode->first_node("Bus"); + while(busNode) { + auto cadPropNode = busNode->first_node("CADProperties"); + if(!cadPropNode) return false; + + auto position = cadPropNode->first_node("Position"); + double posX = GetNodeValueDouble(position, "X"); + double posY = GetNodeValueDouble(position, "Y"); + Bus* bus = new Bus(wxPoint2DDouble(posX, posY)); + + auto size = cadPropNode->first_node("Size"); + double width = GetNodeValueDouble(size, "Width"); + double height = GetNodeValueDouble(size, "Height"); + double angle = GetNodeValueDouble(cadPropNode, "Angle"); + bus->SetWidth(width); + bus->SetHeight(height); + bus->SetPosition(bus->GetPosition()); // Update bus rectangle. + int numRot = angle / bus->GetRotationAngle(); + bool clockwise = true; + if(numRot < 0) { + numRot = std::abs(numRot); + clockwise = false; + } + for(int i = 0; i < numRot; i++) bus->Rotate(clockwise); + + BusElectricalData data = bus->GetEletricalData(); + auto electricalProp = busNode->first_node("ElectricalProperties"); + if(!electricalProp) return false; + + data.name = electricalProp->first_node("Name")->value(); + data.nominalVoltage = GetNodeValueDouble(electricalProp, "NominalVoltage"); + data.nominalVoltageUnit = (ElectricalUnit)GetAttributeValueInt(electricalProp, "NominalVoltage", "UnitID"); + data.isVoltageControlled = GetNodeValueInt(electricalProp, "IsVoltageControlled"); + data.controlledVoltage = GetNodeValueDouble(electricalProp, "ControlledVoltage"); + data.controlledVoltageUnitChoice = GetAttributeValueInt(electricalProp, "ControlledVoltage", "Choice"); + data.slackBus = GetNodeValueInt(electricalProp, "SlackBus"); + auto fault = electricalProp->first_node("Fault"); + data.hasFault = GetNodeValueInt(fault, "HasFault"); + data.faultType = (FaultData)GetNodeValueInt(fault, "Type"); + data.faultLocation = (FaultData)GetNodeValueInt(fault, "Location"); + data.faultResistance = GetNodeValueDouble(fault, "Resistance"); + data.faultReactance = GetNodeValueDouble(fault, "Reactance"); + auto stability = electricalProp->first_node("Stability"); + data.plotBus = GetNodeValueInt(stability, "Plot"); + data.stabHasFault = GetNodeValueInt(stability, "HasFault"); + data.stabFaultTime = GetNodeValueDouble(stability, "FaultTime"); + data.stabFaultLength = GetNodeValueDouble(stability, "FaultLength"); + data.stabFaultResistance = GetNodeValueDouble(stability, "FaultResistance"); + data.stabFaultReactance = GetNodeValueDouble(stability, "FaultReactance"); + + bus->SetElectricalData(data); + elementList.push_back(bus); + busList.push_back(bus); + busNode = busNode->next_sibling("Bus"); + } //} + + //{ Capacitor + auto capacitorListNode = elementsNode->first_node("CapacitorList"); + if(!capacitorListNode) return false; + auto capacitorNode = capacitorListNode->first_node("Capacitor"); + while(capacitorNode) { + Capacitor* capacitor = new Capacitor(); + + auto cadPropNode = capacitorNode->first_node("CADProperties"); + if(!cadPropNode) return false; + + auto position = cadPropNode->first_node("Position"); + double posX = GetNodeValueDouble(position, "X"); + double posY = GetNodeValueDouble(position, "Y"); + auto size = cadPropNode->first_node("Size"); + double width = GetNodeValueDouble(size, "Width"); + double height = GetNodeValueDouble(size, "Height"); + double angle = GetNodeValueDouble(cadPropNode, "Angle"); + auto nodePosition = cadPropNode->first_node("NodePosition"); + double nodePosX = GetNodeValueDouble(nodePosition, "X"); + double nodePosY = GetNodeValueDouble(nodePosition, "Y"); + int parentID = GetNodeValueInt(cadPropNode, "ParentID"); + if(parentID == -1) { + //WRONG!!!!! + Bus* parent = new Bus(); + capacitor->AddParent(parent, wxPoint2DDouble(nodePosX, nodePosY)); + capacitor->StartMove(capacitor->GetPosition()); + capacitor->Move(wxPoint2DDouble(posX, posY)); + capacitor->RemoveParent(parent); + delete parent; + } else { + Bus* parent = busList[parentID]; + capacitor->AddParent(parent, wxPoint2DDouble(nodePosX, nodePosY)); + capacitor->StartMove(capacitor->GetPosition()); + capacitor->Move(wxPoint2DDouble(posX, posY)); + } + capacitor->SetWidth(width); + capacitor->SetHeight(height); + + int numRot = angle / capacitor->GetRotationAngle(); + bool clockwise = true; + if(numRot < 0) { + numRot = std::abs(numRot); + clockwise = false; + } + for(int i = 0; i < numRot; i++) capacitor->Rotate(clockwise); + + elementList.push_back(capacitor); + capacitorNode = capacitorNode->next_sibling("Capacitor"); + } + + m_workspace->SetElementList(elementList); + return true; +} rapidxml::xml_node<>* FileHanding::AppendNode(rapidxml::xml_document<>& doc, rapidxml::xml_node<>* parentNode, @@ -813,3 +953,36 @@ void FileHanding::SetNodeAttribute(rapidxml::xml_document<>& doc, node->append_attribute( doc.allocate_attribute(atrName, doc.allocate_string(wxString::FromCDouble(value, 13).mb_str()))); } + +double FileHanding::GetNodeValueDouble(rapidxml::xml_node<>* parent, const char* nodeName) +{ + double dValue = 0.0; + if(parent) { + auto node = parent->first_node(nodeName); + if(node) wxString(node->value()).ToCDouble(&dValue); + } + return dValue; +} + +int FileHanding::GetNodeValueInt(rapidxml::xml_node<>* parent, const char* nodeName) +{ + long iValue = -1; + if(parent) { + auto node = parent->first_node(nodeName); + if(node) wxString(node->value()).ToCLong(&iValue); + } + return (int)iValue; +} + +int FileHanding::GetAttributeValueInt(rapidxml::xml_node<>* parent, const char* nodeName, const char* atrName) +{ + long iValue = -1; + if(parent) { + auto node = parent->first_node(nodeName); + if(node){ + auto atr = node->first_attribute(atrName); + if(atr) wxString(atr->value()).ToCLong(&iValue); + } + } + return (int)iValue; +} -- cgit From 341fd025a924f779acebcfa0ffcf07f46f8240c9 Mon Sep 17 00:00:00 2001 From: Thales1330 Date: Wed, 14 Dec 2016 21:12:05 -0200 Subject: Many elements open implemented --- Project/FileHanding.cpp | 270 +++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 266 insertions(+), 4 deletions(-) (limited to 'Project/FileHanding.cpp') diff --git a/Project/FileHanding.cpp b/Project/FileHanding.cpp index 1586aa6..2cecb40 100644 --- a/Project/FileHanding.cpp +++ b/Project/FileHanding.cpp @@ -134,7 +134,7 @@ void FileHanding::SaveProject(wxFileName path) auto electricalProp = AppendNode(doc, capacitorNode, "ElectricalProperties"); auto isOnline = AppendNode(doc, electricalProp, "IsOnline"); SetNodeValue(doc, isOnline, capacitor->IsOnline()); - auto name = AppendNode(doc, capacitorNode, "Name"); + auto name = AppendNode(doc, electricalProp, "Name"); SetNodeValue(doc, name, data.name); auto reactivePower = AppendNode(doc, electricalProp, "ReactivePower"); SetNodeValue(doc, reactivePower, data.reactivePower); @@ -178,7 +178,8 @@ void FileHanding::SaveProject(wxFileName path) auto nodePosY = AppendNode(doc, nodePos, "Y"); SetNodeValue(doc, nodePosY, indMotor->GetPointList()[0].m_y); auto parentID = AppendNode(doc, cadProp, "ParentID"); - SetNodeValue(doc, parentID, ((Bus*)indMotor->GetParentList()[0])->GetEletricalData().number); + Bus* parent = (Bus*)indMotor->GetParentList()[0]; + if(parent) SetNodeValue(doc, parentID, parent->GetEletricalData().number); IndMotorElectricalData data = indMotor->GetElectricalData(); auto electricalProp = AppendNode(doc, indMotorNode, "ElectricalProperties"); @@ -872,8 +873,8 @@ bool FileHanding::OpenProject(wxFileName path) double nodePosY = GetNodeValueDouble(nodePosition, "Y"); int parentID = GetNodeValueInt(cadPropNode, "ParentID"); if(parentID == -1) { - //WRONG!!!!! - Bus* parent = new Bus(); + //If the element has no parent, create a temporary one, remove and delete. + Bus* parent = new Bus(wxPoint2DDouble(nodePosX, nodePosY)); capacitor->AddParent(parent, wxPoint2DDouble(nodePosX, nodePosY)); capacitor->StartMove(capacitor->GetPosition()); capacitor->Move(wxPoint2DDouble(posX, posY)); @@ -896,9 +897,270 @@ bool FileHanding::OpenProject(wxFileName path) } for(int i = 0; i < numRot; i++) capacitor->Rotate(clockwise); + auto electricalProp = capacitorNode->first_node("ElectricalProperties"); + if(!electricalProp) return false; + + capacitor->SetOnline(GetNodeValueInt(electricalProp, "IsOnline")); + CapacitorElectricalData data = capacitor->GetElectricalData(); + data.name = electricalProp->first_node("Name")->value(); + data.reactivePower = GetNodeValueDouble(electricalProp, "ReactivePower"); + data.reactivePowerUnit = (ElectricalUnit)GetAttributeValueInt(electricalProp, "ReactivePower", "UnitID"); + + SwitchingData swData; + auto switchingList = electricalProp->first_node("SwitchingList"); + if(!switchingList) return false; + auto swNode = switchingList->first_node("Switching"); + while(swNode) { + swData.swType.push_back((SwitchingType)GetNodeValueInt(swNode, "Type")); + swData.swTime.push_back(GetNodeValueDouble(swNode, "Time")); + swNode = swNode->next_sibling("Switching"); + } + capacitor->SetSwitchingData(swData); + + capacitor->SetElectricalData(data); elementList.push_back(capacitor); capacitorNode = capacitorNode->next_sibling("Capacitor"); } + + //{ IndMotor + auto indMotorListNode = elementsNode->first_node("IndMotorList"); + if(!indMotorListNode) return false; + auto indMotorNode = indMotorListNode->first_node("IndMotor"); + while(indMotorNode) { + IndMotor* indMotor = new IndMotor(); + + auto cadPropNode = indMotorNode->first_node("CADProperties"); + if(!cadPropNode) return false; + + auto position = cadPropNode->first_node("Position"); + double posX = GetNodeValueDouble(position, "X"); + double posY = GetNodeValueDouble(position, "Y"); + auto size = cadPropNode->first_node("Size"); + double width = GetNodeValueDouble(size, "Width"); + double height = GetNodeValueDouble(size, "Height"); + double angle = GetNodeValueDouble(cadPropNode, "Angle"); + auto nodePosition = cadPropNode->first_node("NodePosition"); + double nodePosX = GetNodeValueDouble(nodePosition, "X"); + double nodePosY = GetNodeValueDouble(nodePosition, "Y"); + int parentID = GetNodeValueInt(cadPropNode, "ParentID"); + if(parentID == -1) { + //If the element has no parent, create a temporary one, remove and delete. + Bus* parent = new Bus(wxPoint2DDouble(nodePosX, nodePosY)); + indMotor->AddParent(parent, wxPoint2DDouble(nodePosX, nodePosY)); + indMotor->StartMove(indMotor->GetPosition()); + indMotor->Move(wxPoint2DDouble(posX, posY)); + indMotor->RemoveParent(parent); + delete parent; + } else { + Bus* parent = busList[parentID]; + indMotor->AddParent(parent, wxPoint2DDouble(nodePosX, nodePosY)); + indMotor->StartMove(indMotor->GetPosition()); + indMotor->Move(wxPoint2DDouble(posX, posY)); + } + indMotor->SetWidth(width); + indMotor->SetHeight(height); + + int numRot = angle / indMotor->GetRotationAngle(); + bool clockwise = true; + if(numRot < 0) { + numRot = std::abs(numRot); + clockwise = false; + } + for(int i = 0; i < numRot; i++) indMotor->Rotate(clockwise); + + auto electricalProp = indMotorNode->first_node("ElectricalProperties"); + if(!electricalProp) return false; + + indMotor->SetOnline(GetNodeValueInt(electricalProp, "IsOnline")); + IndMotorElectricalData data = indMotor->GetElectricalData(); + data.name = electricalProp->first_node("Name")->value(); + data.activePower = GetNodeValueDouble(electricalProp, "ActivePower"); + data.activePowerUnit = (ElectricalUnit)GetAttributeValueInt(electricalProp, "ActivePower", "UnitID"); + data.reactivePower = GetNodeValueDouble(electricalProp, "ReactivePower"); + data.reactivePowerUnit = (ElectricalUnit)GetAttributeValueInt(electricalProp, "ReactivePower", "UnitID"); + + indMotor->SetElectricalData(data); + elementList.push_back(indMotor); + indMotorNode = indMotorNode->next_sibling("IndMotor"); + } + + //{ Inductor + auto inductorListNode = elementsNode->first_node("InductorList"); + if(!inductorListNode) return false; + auto inductorNode = inductorListNode->first_node("Inductor"); + while(inductorNode) { + Inductor* inductor = new Inductor(); + + auto cadPropNode = inductorNode->first_node("CADProperties"); + if(!cadPropNode) return false; + + auto position = cadPropNode->first_node("Position"); + double posX = GetNodeValueDouble(position, "X"); + double posY = GetNodeValueDouble(position, "Y"); + auto size = cadPropNode->first_node("Size"); + double width = GetNodeValueDouble(size, "Width"); + double height = GetNodeValueDouble(size, "Height"); + double angle = GetNodeValueDouble(cadPropNode, "Angle"); + auto nodePosition = cadPropNode->first_node("NodePosition"); + double nodePosX = GetNodeValueDouble(nodePosition, "X"); + double nodePosY = GetNodeValueDouble(nodePosition, "Y"); + int parentID = GetNodeValueInt(cadPropNode, "ParentID"); + if(parentID == -1) { + //If the element has no parent, create a temporary one, remove and delete. + Bus* parent = new Bus(wxPoint2DDouble(nodePosX, nodePosY)); + inductor->AddParent(parent, wxPoint2DDouble(nodePosX, nodePosY)); + inductor->StartMove(inductor->GetPosition()); + inductor->Move(wxPoint2DDouble(posX, posY)); + inductor->RemoveParent(parent); + delete parent; + } else { + Bus* parent = busList[parentID]; + inductor->AddParent(parent, wxPoint2DDouble(nodePosX, nodePosY)); + inductor->StartMove(inductor->GetPosition()); + inductor->Move(wxPoint2DDouble(posX, posY)); + } + inductor->SetWidth(width); + inductor->SetHeight(height); + + int numRot = angle / inductor->GetRotationAngle(); + bool clockwise = true; + if(numRot < 0) { + numRot = std::abs(numRot); + clockwise = false; + } + for(int i = 0; i < numRot; i++) inductor->Rotate(clockwise); + + auto electricalProp = inductorNode->first_node("ElectricalProperties"); + if(!electricalProp) return false; + + inductor->SetOnline(GetNodeValueInt(electricalProp, "IsOnline")); + InductorElectricalData data = inductor->GetElectricalData(); + data.name = electricalProp->first_node("Name")->value(); + data.reactivePower = GetNodeValueDouble(electricalProp, "ReactivePower"); + data.reactivePowerUnit = (ElectricalUnit)GetAttributeValueInt(electricalProp, "ReactivePower", "UnitID"); + + SwitchingData swData; + auto switchingList = electricalProp->first_node("SwitchingList"); + if(!switchingList) return false; + auto swNode = switchingList->first_node("Switching"); + while(swNode) { + swData.swType.push_back((SwitchingType)GetNodeValueInt(swNode, "Type")); + swData.swTime.push_back(GetNodeValueDouble(swNode, "Time")); + swNode = swNode->next_sibling("Switching"); + } + inductor->SetSwitchingData(swData); + + inductor->SetElectricalData(data); + elementList.push_back(inductor); + inductorNode = inductorNode->next_sibling("Inductor"); + } + + //{ Line + auto lineListNode = elementsNode->first_node("LineList"); + if(!lineListNode) return false; + auto lineNode = lineListNode->first_node("Line"); + while(lineNode) { + Line* line = new Line(); + + auto cadPropNode = lineNode->first_node("CADProperties"); + if(!cadPropNode) return false; + + // Get nodes points + std::vector ptsList; + auto nodePosList = cadPropNode->first_node("NodeList"); + if(!nodePosList) return false; + auto nodePos = nodePosList->first_node("Node"); + while(nodePos) { + double nodePosX = GetNodeValueDouble(nodePos, "X"); + double nodePosY = GetNodeValueDouble(nodePos, "Y"); + ptsList.push_back(wxPoint2DDouble(nodePosX, nodePosY)); + nodePos = nodePos->next_sibling("Node"); + } + + // Get parents IDs + auto parentIDList = cadPropNode->first_node("ParentIDList"); + if(!parentIDList) return false; + auto parentNode = parentIDList->first_node("ParentID"); + long parentID[2] = {-1, -1}; + while(parentNode) { + long index = 0; + wxString(parentNode->first_attribute("ID")->value()).ToLong(&index); + wxString(parentNode->value()).ToCLong(&parentID[index]); + parentNode = parentNode->next_sibling("ParentID"); + } + + // Set parents (if have) + Bus* parent1, *parent2; + if(parentID[0] == -1) { + parent1 = new Bus(ptsList[0]); + line->AddParent(parent1, ptsList[0]); + } else { + parent1 = busList[parentID[0]]; + line->AddParent(parent1, ptsList[0]); + } + if(parentID[1] == -1) { + parent2 = new Bus(ptsList[ptsList.size() - 1]); + line->AddParent(parent2, ptsList[ptsList.size() - 1]); + } else { + parent2 = busList[parentID[1]]; + line->AddParent(parent2, ptsList[ptsList.size() - 1]); + } + + // Add the others nodes (if have) + std::vector midPts; + for(int i=1; i<(int)ptsList.size() - 1; i++) midPts.push_back(ptsList[i]); + std::vector edgesPts = line->GetPointList(); + edgesPts.insert(edgesPts.begin() + 2, midPts.begin(), midPts.end()); + line->SetPointList(edgesPts); + + if(parentID[0] == -1){ + line->RemoveParent(parent1); + delete parent1; + } + if(parentID[1] == -1){ + line->RemoveParent(parent2); + delete parent2; + } + + auto electricalProp = lineNode->first_node("ElectricalProperties"); + if(!electricalProp) return false; + + line->SetOnline(GetNodeValueInt(electricalProp, "IsOnline")); + LineElectricalData data = line->GetElectricalData(); + data.name = electricalProp->first_node("Name")->value(); + data.nominalVoltage = GetNodeValueDouble(electricalProp, "NominalVoltage"); + data.nominalVoltageUnit = (ElectricalUnit)GetAttributeValueInt(electricalProp, "NominalVoltage", "UnitID"); + data.nominalPower = GetNodeValueDouble(electricalProp, "NominalPower"); + data.nominalPowerUnit = (ElectricalUnit)GetAttributeValueInt(electricalProp, "NominalPower", "UnitID"); + data.resistance = GetNodeValueDouble(electricalProp, "Resistance"); + data.resistanceUnit = (ElectricalUnit)GetAttributeValueInt(electricalProp, "Resistance", "UnitID"); + data.indReactance = GetNodeValueDouble(electricalProp, "IndReactance"); + data.indReactanceUnit = (ElectricalUnit)GetAttributeValueInt(electricalProp, "IndReactance", "UnitID"); + data.capSusceptance = GetNodeValueDouble(electricalProp, "CapSusceptance"); + data.capSusceptanceUnit = (ElectricalUnit)GetAttributeValueInt(electricalProp, "CapSusceptance", "UnitID"); + data.lineSize = GetNodeValueDouble(electricalProp, "LineSize"); + data.useLinePower = GetNodeValueInt(electricalProp, "UseLinePower"); + + auto fault = electricalProp->first_node("Fault"); + data.zeroResistance = GetNodeValueDouble(fault, "ZeroResistance"); + data.zeroIndReactance = GetNodeValueDouble(fault, "ZeroIndReactance"); + data.zeroCapSusceptance = GetNodeValueDouble(fault, "ZeroCapSusceptance"); + + SwitchingData swData; + auto switchingList = electricalProp->first_node("SwitchingList"); + if(!switchingList) return false; + auto swNode = switchingList->first_node("Switching"); + while(swNode) { + swData.swType.push_back((SwitchingType)GetNodeValueInt(swNode, "Type")); + swData.swTime.push_back(GetNodeValueDouble(swNode, "Time")); + swNode = swNode->next_sibling("Switching"); + } + line->SetSwitchingData(swData); + + line->SetElectricalData(data); + elementList.push_back(line); + lineNode = lineNode->next_sibling("Line"); + } m_workspace->SetElementList(elementList); return true; -- cgit From 5cdfee44e75b9a3635350aa261818e0a3bb44c5f Mon Sep 17 00:00:00 2001 From: Thales1330 Date: Thu, 15 Dec 2016 17:23:10 -0200 Subject: File handling implemented --- Project/FileHanding.cpp | 537 +++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 531 insertions(+), 6 deletions(-) (limited to 'Project/FileHanding.cpp') diff --git a/Project/FileHanding.cpp b/Project/FileHanding.cpp index 2cecb40..33d66cc 100644 --- a/Project/FileHanding.cpp +++ b/Project/FileHanding.cpp @@ -454,6 +454,10 @@ void FileHanding::SaveProject(wxFileName path) SetNodeValue(doc, zeroResistance, data.zeroResistance); auto zeroReactance = AppendNode(doc, fault, "ZeroReactance"); SetNodeValue(doc, zeroReactance, data.zeroReactance); + auto groundResistance = AppendNode(doc, fault, "GroundResistance"); + SetNodeValue(doc, groundResistance, data.groundResistance); + auto groundReactance = AppendNode(doc, fault, "GroundReactance"); + SetNodeValue(doc, groundReactance, data.groundReactance); auto groundNeutral = AppendNode(doc, fault, "GroundNeutral"); SetNodeValue(doc, groundNeutral, data.groundNeutral); @@ -580,6 +584,10 @@ void FileHanding::SaveProject(wxFileName path) SetNodeValue(doc, zeroResistance, data.zeroResistance); auto zeroReactance = AppendNode(doc, fault, "ZeroReactance"); SetNodeValue(doc, zeroReactance, data.zeroReactance); + auto groundResistance = AppendNode(doc, fault, "GroundResistance"); + SetNodeValue(doc, groundResistance, data.groundResistance); + auto groundReactance = AppendNode(doc, fault, "GroundReactance"); + SetNodeValue(doc, groundReactance, data.groundReactance); auto groundNeutral = AppendNode(doc, fault, "GroundNeutral"); SetNodeValue(doc, groundNeutral, data.groundNeutral); @@ -790,7 +798,17 @@ bool FileHanding::OpenProject(wxFileName path) auto elementsNode = projectNode->first_node("Elements"); if(!elementsNode) return false; std::vector elementList; - std::vector busList; // To fill parents. + // Save lists individually to get parents + std::vector busList; + std::vector capacitorList; + std::vector indMotorList; + std::vector inductorList; + std::vector lineList; + std::vector loadList; + std::vector syncGeneratorList; + std::vector syncMotorList; + std::vector transformerList; + std::vector textList; //{ Bus auto busListNode = elementsNode->first_node("BusList"); @@ -919,8 +937,9 @@ bool FileHanding::OpenProject(wxFileName path) capacitor->SetElectricalData(data); elementList.push_back(capacitor); + capacitorList.push_back(capacitor); capacitorNode = capacitorNode->next_sibling("Capacitor"); - } + } //} //{ IndMotor auto indMotorListNode = elementsNode->first_node("IndMotorList"); @@ -981,8 +1000,9 @@ bool FileHanding::OpenProject(wxFileName path) indMotor->SetElectricalData(data); elementList.push_back(indMotor); + indMotorList.push_back(indMotor); indMotorNode = indMotorNode->next_sibling("IndMotor"); - } + } //} //{ Inductor auto inductorListNode = elementsNode->first_node("InductorList"); @@ -1052,8 +1072,9 @@ bool FileHanding::OpenProject(wxFileName path) inductor->SetElectricalData(data); elementList.push_back(inductor); + inductorList.push_back(inductor); inductorNode = inductorNode->next_sibling("Inductor"); - } + } //} //{ Line auto lineListNode = elementsNode->first_node("LineList"); @@ -1122,6 +1143,7 @@ bool FileHanding::OpenProject(wxFileName path) delete parent2; } + auto electricalProp = lineNode->first_node("ElectricalProperties"); if(!electricalProp) return false; @@ -1159,10 +1181,513 @@ bool FileHanding::OpenProject(wxFileName path) line->SetElectricalData(data); elementList.push_back(line); + lineList.push_back(line); lineNode = lineNode->next_sibling("Line"); - } - + } //} + + //{ Load + auto loadListNode = elementsNode->first_node("LoadList"); + if(!loadListNode) return false; + auto loadNode = loadListNode->first_node("Load"); + while(loadNode) { + Load* load = new Load(); + + auto cadPropNode = loadNode->first_node("CADProperties"); + if(!cadPropNode) return false; + + auto position = cadPropNode->first_node("Position"); + double posX = GetNodeValueDouble(position, "X"); + double posY = GetNodeValueDouble(position, "Y"); + auto size = cadPropNode->first_node("Size"); + double width = GetNodeValueDouble(size, "Width"); + double height = GetNodeValueDouble(size, "Height"); + double angle = GetNodeValueDouble(cadPropNode, "Angle"); + auto nodePosition = cadPropNode->first_node("NodePosition"); + double nodePosX = GetNodeValueDouble(nodePosition, "X"); + double nodePosY = GetNodeValueDouble(nodePosition, "Y"); + int parentID = GetNodeValueInt(cadPropNode, "ParentID"); + if(parentID == -1) { + //If the element has no parent, create a temporary one, remove and delete. + Bus* parent = new Bus(wxPoint2DDouble(nodePosX, nodePosY)); + load->AddParent(parent, wxPoint2DDouble(nodePosX, nodePosY)); + load->StartMove(load->GetPosition()); + load->Move(wxPoint2DDouble(posX, posY)); + load->RemoveParent(parent); + delete parent; + } else { + Bus* parent = busList[parentID]; + load->AddParent(parent, wxPoint2DDouble(nodePosX, nodePosY)); + load->StartMove(load->GetPosition()); + load->Move(wxPoint2DDouble(posX, posY)); + } + load->SetWidth(width); + load->SetHeight(height); + + int numRot = angle / load->GetRotationAngle(); + bool clockwise = true; + if(numRot < 0) { + numRot = std::abs(numRot); + clockwise = false; + } + for(int i = 0; i < numRot; i++) load->Rotate(clockwise); + + auto electricalProp = loadNode->first_node("ElectricalProperties"); + if(!electricalProp) return false; + + load->SetOnline(GetNodeValueInt(electricalProp, "IsOnline")); + LoadElectricalData data = load->GetElectricalData(); + data.name = electricalProp->first_node("Name")->value(); + data.activePower = GetNodeValueDouble(electricalProp, "ActivePower"); + data.activePowerUnit = (ElectricalUnit)GetAttributeValueInt(electricalProp, "ActivePower", "UnitID"); + data.reactivePower = GetNodeValueDouble(electricalProp, "ReactivePower"); + data.reactivePowerUnit = (ElectricalUnit)GetAttributeValueInt(electricalProp, "ReactivePower", "UnitID"); + data.loadType = (LoadType)GetNodeValueInt(electricalProp, "LoadType"); + + SwitchingData swData; + auto switchingList = electricalProp->first_node("SwitchingList"); + if(!switchingList) return false; + auto swNode = switchingList->first_node("Switching"); + while(swNode) { + swData.swType.push_back((SwitchingType)GetNodeValueInt(swNode, "Type")); + swData.swTime.push_back(GetNodeValueDouble(swNode, "Time")); + swNode = swNode->next_sibling("Switching"); + } + load->SetSwitchingData(swData); + + load->SetElectricalData(data); + elementList.push_back(load); + loadList.push_back(load); + loadNode = loadNode->next_sibling("Load"); + } //} + + //{ SyncGenerator + auto syncGeneratorListNode = elementsNode->first_node("SyncGeneratorList"); + if(!syncGeneratorListNode) return false; + auto syncGeneratorNode = syncGeneratorListNode->first_node("SyncGenerator"); + while(syncGeneratorNode) { + SyncGenerator* syncGenerator = new SyncGenerator(); + + auto cadPropNode = syncGeneratorNode->first_node("CADProperties"); + if(!cadPropNode) return false; + + auto position = cadPropNode->first_node("Position"); + double posX = GetNodeValueDouble(position, "X"); + double posY = GetNodeValueDouble(position, "Y"); + auto size = cadPropNode->first_node("Size"); + double width = GetNodeValueDouble(size, "Width"); + double height = GetNodeValueDouble(size, "Height"); + double angle = GetNodeValueDouble(cadPropNode, "Angle"); + auto nodePosition = cadPropNode->first_node("NodePosition"); + double nodePosX = GetNodeValueDouble(nodePosition, "X"); + double nodePosY = GetNodeValueDouble(nodePosition, "Y"); + int parentID = GetNodeValueInt(cadPropNode, "ParentID"); + if(parentID == -1) { + //If the element has no parent, create a temporary one, remove and delete. + Bus* parent = new Bus(wxPoint2DDouble(nodePosX, nodePosY)); + syncGenerator->AddParent(parent, wxPoint2DDouble(nodePosX, nodePosY)); + syncGenerator->StartMove(syncGenerator->GetPosition()); + syncGenerator->Move(wxPoint2DDouble(posX, posY)); + syncGenerator->RemoveParent(parent); + delete parent; + } else { + Bus* parent = busList[parentID]; + syncGenerator->AddParent(parent, wxPoint2DDouble(nodePosX, nodePosY)); + syncGenerator->StartMove(syncGenerator->GetPosition()); + syncGenerator->Move(wxPoint2DDouble(posX, posY)); + } + syncGenerator->SetWidth(width); + syncGenerator->SetHeight(height); + + int numRot = angle / syncGenerator->GetRotationAngle(); + bool clockwise = true; + if(numRot < 0) { + numRot = std::abs(numRot); + clockwise = false; + } + for(int i = 0; i < numRot; i++) syncGenerator->Rotate(clockwise); + + auto electricalProp = syncGeneratorNode->first_node("ElectricalProperties"); + if(!electricalProp) return false; + + syncGenerator->SetOnline(GetNodeValueInt(electricalProp, "IsOnline")); + SyncGeneratorElectricalData data = syncGenerator->GetElectricalData(); + data.name = electricalProp->first_node("Name")->value(); + data.nominalPower = GetNodeValueDouble(electricalProp, "NominalPower"); + data.nominalPowerUnit = (ElectricalUnit)GetAttributeValueInt(electricalProp, "NominalPower", "UnitID"); + data.nominalVoltage = GetNodeValueDouble(electricalProp, "NominalVoltage"); + data.nominalVoltageUnit = (ElectricalUnit)GetAttributeValueInt(electricalProp, "NominalVoltage", "UnitID"); + data.activePower = GetNodeValueDouble(electricalProp, "ActivePower"); + data.activePowerUnit = (ElectricalUnit)GetAttributeValueInt(electricalProp, "ActivePower", "UnitID"); + data.reactivePower = GetNodeValueDouble(electricalProp, "ReactivePower"); + data.reactivePowerUnit = (ElectricalUnit)GetAttributeValueInt(electricalProp, "ReactivePower", "UnitID"); + data.haveMaxReactive = GetNodeValueInt(electricalProp, "HaveMaxReactive"); + data.maxReactive = GetNodeValueDouble(electricalProp, "MaxReactive"); + data.maxReactiveUnit = (ElectricalUnit)GetAttributeValueInt(electricalProp, "MaxReactive", "UnitID"); + data.haveMinReactive = GetNodeValueInt(electricalProp, "HaveMinReactive"); + data.minReactive = GetNodeValueDouble(electricalProp, "MinReactive"); + data.minReactiveUnit = (ElectricalUnit)GetAttributeValueInt(electricalProp, "MinReactive", "UnitID"); + data.useMachineBase = GetNodeValueInt(electricalProp, "UseMachineBase"); + + auto fault = electricalProp->first_node("Fault"); + if(!fault) return false; + data.positiveResistance = GetNodeValueDouble(fault, "PositiveResistance"); + data.positiveReactance = GetNodeValueDouble(fault, "PositiveReactance"); + data.negativeResistance = GetNodeValueDouble(fault, "NegativeResistance"); + data.negativeReactance = GetNodeValueDouble(fault, "NegativeReactance"); + data.zeroResistance = GetNodeValueDouble(fault, "ZeroResistance"); + data.zeroReactance = GetNodeValueDouble(fault, "ZeroReactance"); + data.groundResistance = GetNodeValueDouble(fault, "GroundResistance"); + data.groundReactance = GetNodeValueDouble(fault, "GroundReactance"); + data.groundNeutral = GetNodeValueInt(fault, "GroundNeutral"); + + auto stability = electricalProp->first_node("Stability"); + if(!stability) return false; + data.plotSyncMachine = GetNodeValueInt(stability, "PlotSyncMachine"); + data.inertia = GetNodeValueDouble(stability, "Inertia"); + data.damping = GetNodeValueDouble(stability, "Damping"); + data.useAVR = GetNodeValueInt(stability, "UseAVR"); + data.useSpeedGovernor = GetNodeValueInt(stability, "UseSpeedGovernor"); + data.armResistance = GetNodeValueDouble(stability, "ArmResistance"); + data.potierReactance = GetNodeValueDouble(stability, "PotierReactance"); + data.satFactor = GetNodeValueDouble(stability, "SatFactor"); + data.syncXd = GetNodeValueDouble(stability, "SyncXd"); + data.syncXq = GetNodeValueDouble(stability, "SyncXq"); + data.transXd = GetNodeValueDouble(stability, "TransXd"); + data.transXq = GetNodeValueDouble(stability, "TransXq"); + data.transTd0 = GetNodeValueDouble(stability, "TransTd0"); + data.transTq0 = GetNodeValueDouble(stability, "TransTq0"); + data.subXd = GetNodeValueDouble(stability, "SubXd"); + data.subXq = GetNodeValueDouble(stability, "SubXq"); + data.subTd0 = GetNodeValueDouble(stability, "SubTd0"); + data.subTq0 = GetNodeValueDouble(stability, "SubTq0"); + + SwitchingData swData; + auto switchingList = electricalProp->first_node("SwitchingList"); + if(!switchingList) return false; + auto swNode = switchingList->first_node("Switching"); + while(swNode) { + swData.swType.push_back((SwitchingType)GetNodeValueInt(swNode, "Type")); + swData.swTime.push_back(GetNodeValueDouble(swNode, "Time")); + swNode = swNode->next_sibling("Switching"); + } + syncGenerator->SetSwitchingData(swData); + + syncGenerator->SetElectricalData(data); + elementList.push_back(syncGenerator); + syncGeneratorList.push_back(syncGenerator); + syncGeneratorNode = syncGeneratorNode->next_sibling("SyncGenerator"); + } //} + + //{ SyncMotor + auto syncMotorListNode = elementsNode->first_node("SyncMotorList"); + if(!syncMotorListNode) return false; + auto syncMotorNode = syncMotorListNode->first_node("SyncMotor"); + while(syncMotorNode) { + SyncMotor* syncMotor = new SyncMotor(); + + auto cadPropNode = syncMotorNode->first_node("CADProperties"); + if(!cadPropNode) return false; + + auto position = cadPropNode->first_node("Position"); + double posX = GetNodeValueDouble(position, "X"); + double posY = GetNodeValueDouble(position, "Y"); + auto size = cadPropNode->first_node("Size"); + double width = GetNodeValueDouble(size, "Width"); + double height = GetNodeValueDouble(size, "Height"); + double angle = GetNodeValueDouble(cadPropNode, "Angle"); + auto nodePosition = cadPropNode->first_node("NodePosition"); + double nodePosX = GetNodeValueDouble(nodePosition, "X"); + double nodePosY = GetNodeValueDouble(nodePosition, "Y"); + int parentID = GetNodeValueInt(cadPropNode, "ParentID"); + if(parentID == -1) { + //If the element has no parent, create a temporary one, remove and delete. + Bus* parent = new Bus(wxPoint2DDouble(nodePosX, nodePosY)); + syncMotor->AddParent(parent, wxPoint2DDouble(nodePosX, nodePosY)); + syncMotor->StartMove(syncMotor->GetPosition()); + syncMotor->Move(wxPoint2DDouble(posX, posY)); + syncMotor->RemoveParent(parent); + delete parent; + } else { + Bus* parent = busList[parentID]; + syncMotor->AddParent(parent, wxPoint2DDouble(nodePosX, nodePosY)); + syncMotor->StartMove(syncMotor->GetPosition()); + syncMotor->Move(wxPoint2DDouble(posX, posY)); + } + syncMotor->SetWidth(width); + syncMotor->SetHeight(height); + + int numRot = angle / syncMotor->GetRotationAngle(); + bool clockwise = true; + if(numRot < 0) { + numRot = std::abs(numRot); + clockwise = false; + } + for(int i = 0; i < numRot; i++) syncMotor->Rotate(clockwise); + + auto electricalProp = syncMotorNode->first_node("ElectricalProperties"); + if(!electricalProp) return false; + + syncMotor->SetOnline(GetNodeValueInt(electricalProp, "IsOnline")); + SyncMotorElectricalData data = syncMotor->GetElectricalData(); + data.name = electricalProp->first_node("Name")->value(); + data.nominalPower = GetNodeValueDouble(electricalProp, "NominalPower"); + data.nominalPowerUnit = (ElectricalUnit)GetAttributeValueInt(electricalProp, "NominalPower", "UnitID"); + //data.nominalVoltage = GetNodeValueDouble(electricalProp, "NominalVoltage"); + //data.nominalVoltageUnit = (ElectricalUnit)GetAttributeValueInt(electricalProp, "NominalVoltage", "UnitID"); + data.activePower = GetNodeValueDouble(electricalProp, "ActivePower"); + data.activePowerUnit = (ElectricalUnit)GetAttributeValueInt(electricalProp, "ActivePower", "UnitID"); + data.reactivePower = GetNodeValueDouble(electricalProp, "ReactivePower"); + data.reactivePowerUnit = (ElectricalUnit)GetAttributeValueInt(electricalProp, "ReactivePower", "UnitID"); + data.haveMaxReactive = GetNodeValueInt(electricalProp, "HaveMaxReactive"); + data.maxReactive = GetNodeValueDouble(electricalProp, "MaxReactive"); + data.maxReactiveUnit = (ElectricalUnit)GetAttributeValueInt(electricalProp, "MaxReactive", "UnitID"); + data.haveMinReactive = GetNodeValueInt(electricalProp, "HaveMinReactive"); + data.minReactive = GetNodeValueDouble(electricalProp, "MinReactive"); + data.minReactiveUnit = (ElectricalUnit)GetAttributeValueInt(electricalProp, "MinReactive", "UnitID"); + data.useMachineBase = GetNodeValueInt(electricalProp, "UseMachineBase"); + + auto fault = electricalProp->first_node("Fault"); + if(!fault) return false; + data.positiveResistance = GetNodeValueDouble(fault, "PositiveResistance"); + data.positiveReactance = GetNodeValueDouble(fault, "PositiveReactance"); + data.negativeResistance = GetNodeValueDouble(fault, "NegativeResistance"); + data.negativeReactance = GetNodeValueDouble(fault, "NegativeReactance"); + data.zeroResistance = GetNodeValueDouble(fault, "ZeroResistance"); + data.zeroReactance = GetNodeValueDouble(fault, "ZeroReactance"); + data.groundResistance = GetNodeValueDouble(fault, "GroundResistance"); + data.groundReactance = GetNodeValueDouble(fault, "GroundReactance"); + data.groundNeutral = GetNodeValueInt(fault, "GroundNeutral"); + + /*SwitchingData swData; + auto switchingList = electricalProp->first_node("SwitchingList"); + if(!switchingList) return false; + auto swNode = switchingList->first_node("Switching"); + while(swNode) { + swData.swType.push_back((SwitchingType)GetNodeValueInt(swNode, "Type")); + swData.swTime.push_back(GetNodeValueDouble(swNode, "Time")); + swNode = swNode->next_sibling("Switching"); + } + syncMotor->SetSwitchingData(swData);*/ + + syncMotor->SetElectricalData(data); + elementList.push_back(syncMotor); + syncMotorList.push_back(syncMotor); + syncMotorNode = syncMotorNode->next_sibling("SyncMotor"); + } //} + + //{ Transformer + auto transformerListNode = elementsNode->first_node("TransformerList"); + if(!transformerListNode) return false; + auto transfomerNode = transformerListNode->first_node("Transfomer"); + while(transfomerNode) { + Transformer* transformer = new Transformer(); + + auto cadPropNode = transfomerNode->first_node("CADProperties"); + if(!cadPropNode) return false; + + auto position = cadPropNode->first_node("Position"); + double posX = GetNodeValueDouble(position, "X"); + double posY = GetNodeValueDouble(position, "Y"); + auto size = cadPropNode->first_node("Size"); + double width = GetNodeValueDouble(size, "Width"); + double height = GetNodeValueDouble(size, "Height"); + double angle = GetNodeValueDouble(cadPropNode, "Angle"); + + // Get nodes points + std::vector ptsList; + auto nodePosList = cadPropNode->first_node("NodeList"); + if(!nodePosList) return false; + auto nodePos = nodePosList->first_node("Node"); + while(nodePos) { + double nodePosX = GetNodeValueDouble(nodePos, "X"); + double nodePosY = GetNodeValueDouble(nodePos, "Y"); + ptsList.push_back(wxPoint2DDouble(nodePosX, nodePosY)); + nodePos = nodePos->next_sibling("Node"); + } + + // Get parents IDs + auto parentIDList = cadPropNode->first_node("ParentIDList"); + if(!parentIDList) return false; + auto parentNode = parentIDList->first_node("ParentID"); + long parentID[2] = {-1, -1}; + while(parentNode) { + long index = 0; + wxString(parentNode->first_attribute("ID")->value()).ToLong(&index); + wxString(parentNode->value()).ToCLong(&parentID[index]); + parentNode = parentNode->next_sibling("ParentID"); + } + + // Set parents (if have) + Bus* parent1, *parent2; + if(parentID[0] == -1) { + parent1 = new Bus(ptsList[0]); + transformer->AddParent(parent1, ptsList[0]); + } else { + parent1 = busList[parentID[0]]; + transformer->AddParent(parent1, ptsList[0]); + } + if(parentID[1] == -1) { + parent2 = new Bus(ptsList[ptsList.size() - 1]); + transformer->AddParent(parent2, ptsList[ptsList.size() - 1]); + } else { + parent2 = busList[parentID[1]]; + transformer->AddParent(parent2, ptsList[ptsList.size() - 1]); + } + + transformer->StartMove(transformer->GetPosition()); + transformer->Move(wxPoint2DDouble(posX, posY)); + + if(parentID[0] == -1){ + transformer->RemoveParent(parent1); + delete parent1; + } + if(parentID[1] == -1){ + transformer->RemoveParent(parent2); + delete parent2; + } + + transformer->SetWidth(width); + transformer->SetHeight(height); + + int numRot = angle / transformer->GetRotationAngle(); + bool clockwise = true; + if(numRot < 0) { + numRot = std::abs(numRot); + clockwise = false; + } + for(int i = 0; i < numRot; i++) transformer->Rotate(clockwise); + + auto electricalProp = transfomerNode->first_node("ElectricalProperties"); + if(!electricalProp) return false; + + transformer->SetOnline(GetNodeValueInt(electricalProp, "IsOnline")); + TransformerElectricalData data = transformer->GetElectricalData(); + data.name = electricalProp->first_node("Name")->value(); + data.primaryNominalVoltage = GetNodeValueDouble(electricalProp, "PrimaryNominalVoltage"); + data.primaryNominalVoltageUnit = (ElectricalUnit)GetAttributeValueInt(electricalProp, "PrimaryNominalVoltage", "UnitID"); + data.secondaryNominalVoltage = GetNodeValueDouble(electricalProp, "SecondaryNominalVoltage"); + data.secondaryNominalVoltageUnit = (ElectricalUnit)GetAttributeValueInt(electricalProp, "SecondaryNominalVoltage", "UnitID"); + data.nominalPower = GetNodeValueDouble(electricalProp, "NominalPower"); + data.nominalPowerUnit = (ElectricalUnit)GetAttributeValueInt(electricalProp, "NominalPower", "UnitID"); + data.resistance = GetNodeValueDouble(electricalProp, "Resistance"); + data.resistanceUnit = (ElectricalUnit)GetAttributeValueInt(electricalProp, "Resistance", "UnitID"); + data.indReactance = GetNodeValueDouble(electricalProp, "IndReactance"); + data.indReactanceUnit = (ElectricalUnit)GetAttributeValueInt(electricalProp, "IndReactance", "UnitID"); + data.connection = (TransformerConnection) GetNodeValueInt(electricalProp, "Connection"); + data.turnsRatio = GetNodeValueDouble(electricalProp, "TurnsRatio"); + data.phaseShift = GetNodeValueDouble(electricalProp, "PhaseShift"); + data.useTransformerPower = GetNodeValueInt(electricalProp, "UseTransfomerPower"); + + auto fault = electricalProp->first_node("Fault"); + data.zeroResistance = GetNodeValueDouble(fault, "ZeroResistance"); + data.zeroIndReactance = GetNodeValueDouble(fault, "ZeroIndReactance"); + data.primaryGrndResistance = GetNodeValueDouble(fault, "PrimaryGrndResistance"); + data.primaryGrndReactance = GetNodeValueDouble(fault, "PrimaryGrndReactance"); + data.secondaryGrndResistance = GetNodeValueDouble(fault, "SecondaryGrndResistance"); + data.secondaryGrndReactance = GetNodeValueDouble(fault, "SecondaryGrndReactance"); + + SwitchingData swData; + auto switchingList = electricalProp->first_node("SwitchingList"); + if(!switchingList) return false; + auto swNode = switchingList->first_node("Switching"); + while(swNode) { + swData.swType.push_back((SwitchingType)GetNodeValueInt(swNode, "Type")); + swData.swTime.push_back(GetNodeValueDouble(swNode, "Time")); + swNode = swNode->next_sibling("Switching"); + } + transformer->SetSwitchingData(swData); + + transformer->SetElectricaData(data); + elementList.push_back(transformer); + transformerList.push_back(transformer); + transfomerNode = transfomerNode->next_sibling("Transfomer"); + } //} + + //{ Text + auto textListNode = elementsNode->first_node("TextList"); + if(!textListNode) return false; + auto textNode = textListNode->first_node("Text"); + while(textNode) { + + auto cadPropNode = textNode->first_node("CADProperties"); + if(!cadPropNode) return false; + + auto position = cadPropNode->first_node("Position"); + double posX = GetNodeValueDouble(position, "X"); + double posY = GetNodeValueDouble(position, "Y"); + auto size = cadPropNode->first_node("Size"); + double width = GetNodeValueDouble(size, "Width"); + double height = GetNodeValueDouble(size, "Height"); + double angle = GetNodeValueDouble(cadPropNode, "Angle"); + + Text* text = new Text(wxPoint2DDouble(posX, posY)); + + text->SetWidth(width); + text->SetHeight(height); + + auto textProperties = textNode->first_node("TextProperties"); + if(!textProperties) return false; + text->SetElementType((ElementType)GetNodeValueDouble(textProperties, "ElementType")); + text->SetElementNumber(GetNodeValueInt(textProperties, "ElementNumber")); + switch(text->GetElementType()) { + case TYPE_NONE: break; + case TYPE_BUS: { + Bus* bus = busList[text->GetElementNumber()]; + text->SetElement(bus); + } break; + case TYPE_CAPACITOR: { + Capacitor* capacitor = capacitorList[text->GetElementNumber()]; + text->SetElement(capacitor); + } break; + case TYPE_IND_MOTOR: { + IndMotor* indMotor = indMotorList[text->GetElementNumber()]; + text->SetElement(indMotor); + } break; + case TYPE_INDUCTOR: { + Inductor* inductor = inductorList[text->GetElementNumber()]; + text->SetElement(inductor); + } break; + case TYPE_LINE: { + Line* line = lineList[text->GetElementNumber()]; + text->SetElement(line); + } break; + case TYPE_LOAD: { + Load* load = loadList[text->GetElementNumber()]; + text->SetElement(load); + } break; + case TYPE_SYNC_GENERATOR: { + SyncGenerator* syncGenerator = syncGeneratorList[text->GetElementNumber()]; + text->SetElement(syncGenerator); + } break; + case TYPE_SYNC_MOTOR: { + SyncMotor* syncMotor = syncMotorList[text->GetElementNumber()]; + text->SetElement(syncMotor); + } break; + case TYPE_TRANSFORMER: { + Transformer* transformer = transformerList[text->GetElementNumber()]; + text->SetElement(transformer); + } break; + } + text->SetDataType((DataType)GetNodeValueDouble(textProperties, "DataType")); + text->SetUnit((ElectricalUnit)GetNodeValueDouble(textProperties, "DataUnit")); + text->SetDirection(GetNodeValueDouble(textProperties, "Direction")); + text->SetDecimalPlaces(GetNodeValueDouble(textProperties, "DecimalPlaces")); + + int numRot = angle / text->GetRotationAngle(); + bool clockwise = true; + if(numRot < 0) { + numRot = std::abs(numRot); + clockwise = false; + } + for(int i = 0; i < numRot; i++) text->Rotate(clockwise); + + textList.push_back(text); + textNode = textNode->next_sibling("Text"); + } //} + m_workspace->SetElementList(elementList); + m_workspace->SetTextList(textList); + m_workspace->UpdateTextElements(); return true; } -- cgit