From b306118b2683cf6f264b5f1617c3e0e62a6c9042 Mon Sep 17 00:00:00 2001 From: Thales1330 Date: Tue, 1 Nov 2016 19:36:24 -0200 Subject: Power flow (gs) under implementation --- Project/ElectricCalculation.cpp | 189 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 189 insertions(+) create mode 100644 Project/ElectricCalculation.cpp (limited to 'Project/ElectricCalculation.cpp') diff --git a/Project/ElectricCalculation.cpp b/Project/ElectricCalculation.cpp new file mode 100644 index 0000000..389af4a --- /dev/null +++ b/Project/ElectricCalculation.cpp @@ -0,0 +1,189 @@ +#include "ElectricCalculation.h" +#include "Element.h" +#include "Bus.h" +#include "Capacitor.h" +#include "IndMotor.h" +#include "Inductor.h" +#include "Line.h" +#include "Load.h" +#include "SyncGenerator.h" +#include "SyncMotor.h" +#include "Transformer.h" + +ElectricCalculation::ElectricCalculation() {} +ElectricCalculation::~ElectricCalculation() {} +void ElectricCalculation::GetElementsFromList(std::vector elementList) +{ + m_busList.clear(); + m_capacitorList.clear(); + m_indMotorList.clear(); + m_inductorList.clear(); + m_lineList.clear(); + m_loadList.clear(); + m_syncGeneratorList.clear(); + m_syncMotorList.clear(); + m_transformerList.clear(); + // Bad design? + for(auto it = elementList.begin(); it != elementList.end(); it++) { + Element* element = *it; + if(typeid(*element) == typeid(Bus)) + m_busList.push_back((Bus*)element); + else if(typeid(*element) == typeid(Capacitor)) + m_capacitorList.push_back((Capacitor*)element); + else if(typeid(*element) == typeid(IndMotor)) + m_indMotorList.push_back((IndMotor*)element); + else if(typeid(*element) == typeid(Inductor)) + m_inductorList.push_back((Inductor*)element); + else if(typeid(*element) == typeid(Line)) + m_lineList.push_back((Line*)element); + else if(typeid(*element) == typeid(Load)) + m_loadList.push_back((Load*)element); + else if(typeid(*element) == typeid(SyncGenerator)) + m_syncGeneratorList.push_back((SyncGenerator*)element); + else if(typeid(*element) == typeid(SyncMotor)) + m_syncMotorList.push_back((SyncMotor*)element); + else if(typeid(*element) == typeid(Transformer)) + m_transformerList.push_back((Transformer*)element); + } +} + +bool ElectricCalculation::GetYBus(std::vector > >& yBus, double systemPowerBase) +{ + if(m_busList.size() == 0) return false; + + // Clear and fill with zeros the Ybus + yBus.clear(); + for(int i = 0; i < (int)m_busList.size(); i++) { + std::vector > line; + for(int j = 0; j < (int)m_busList.size(); j++) { + line.push_back(std::complex(0.0, 0.0)); + } + yBus.push_back(line); + } + + // Build connection map + std::vector > lineMap; + std::vector > transfomerMap; + lineMap.resize(m_lineList.size()); + transfomerMap.resize(m_transformerList.size()); + + // Get the connection map for + int busNumber = 0; + for(auto itb = m_busList.begin(); itb != m_busList.end(); itb++) { + Bus* bus = *itb; + + // Get power line connection map + for(int i = 0; i < (int)m_lineList.size(); i++) { + for(int j = 0; j < (int)m_lineList[i]->GetParentList().size(); j++) { + if(bus == m_lineList[i]->GetParentList()[j]) lineMap[i].push_back(busNumber); + } + } + + // Get transformer connection map + for(int i = 0; i < (int)m_transformerList.size(); i++) { + for(int j = 0; j < (int)m_transformerList[i]->GetParentList().size(); j++) { + if(bus == m_transformerList[i]->GetParentList()[j]) transfomerMap[i].push_back(busNumber); + } + } + + // Load + for(auto itlo = m_loadList.begin(); itlo != m_loadList.end(); itlo++) { + Load* load = *itlo; + if(bus == load->GetParentList()[0]) { + LoadElectricalData data = load->GetPUElectricalData(systemPowerBase); + if(data.loadType == CONST_IMPEDANCE) + yBus[busNumber][busNumber] += std::complex(data.activePower, -data.reactivePower); + } + } + + // Capacitor + for(auto itca = m_capacitorList.begin(); itca != m_capacitorList.end(); itca++) { + Capacitor* capacitor = *itca; + if(bus == capacitor->GetParentList()[0]) { + CapacitorElectricalData data = capacitor->GetPUElectricalData(systemPowerBase); + yBus[busNumber][busNumber] += std::complex(0.0, data.reactivePower); + } + } + + // Inductor + for(auto itin = m_inductorList.begin(); itin != m_inductorList.end(); itin++) { + Inductor* inductor = *itin; + if(bus == inductor->GetParentList()[0]) { + InductorElectricalData data = inductor->GetPUElectricalData(systemPowerBase); + yBus[busNumber][busNumber] += std::complex(0.0, -data.reactivePower); + } + } + + busNumber++; + } + + // Power line + int lineNumber = 0; + for(auto itl = m_lineList.begin(); itl != m_lineList.end(); itl++) { + Line* line = *itl; + LineElectricalData data = line->GetElectricalData(); + if(line->IsOnline()) { + yBus[lineMap[lineNumber][0]][lineMap[lineNumber][1]] -= + 1.0 / std::complex(data.resistance, data.indReactance); + yBus[lineMap[lineNumber][1]][lineMap[lineNumber][0]] -= + 1.0 / std::complex(data.resistance, data.indReactance); + + yBus[lineMap[lineNumber][0]][lineMap[lineNumber][0]] += + 1.0 / std::complex(data.resistance, data.indReactance); + yBus[lineMap[lineNumber][1]][lineMap[lineNumber][1]] += + 1.0 / std::complex(data.resistance, data.indReactance); + + yBus[lineMap[lineNumber][0]][lineMap[lineNumber][0]] += + std::complex(0.0, data.capSusceptance / 2.0); + yBus[lineMap[lineNumber][1]][lineMap[lineNumber][1]] += + std::complex(0.0, data.capSusceptance / 2.0); + } + lineNumber++; + } + + int transformerNumber = 0; + for(auto itt = m_transformerList.begin(); itt != m_transformerList.end(); ++itt) { + Transformer* transformer = *itt; + TransformerElectricalData data = transformer->GetElectricalData(); + + if(transformer->IsOnline()) { + // If the transformer have nominal turns ratio (1.0) and no phase shifting, it will be modelled as series + // impedance. + if(data.turnsRatio == 1.0 && data.phaseShift == 0.0) { + yBus[transfomerMap[transformerNumber][0]][transfomerMap[transformerNumber][1]] += + -1.0 / std::complex(data.resistance, data.indReactance); + yBus[transfomerMap[transformerNumber][1]][transfomerMap[transformerNumber][0]] += + -1.0 / std::complex(data.resistance, data.indReactance); + + yBus[transfomerMap[transformerNumber][0]][transfomerMap[transformerNumber][0]] += + 1.0 / std::complex(data.resistance, data.indReactance); + yBus[transfomerMap[transformerNumber][1]][transfomerMap[transformerNumber][1]] += + 1.0 / std::complex(data.resistance, data.indReactance); + } + // If the transformer have no-nominal turn ratio and/or phase shifting, it will be modelled in a different + // way (see references). + //[Ref. 1: Elementos de analise de sistemas de potencia - Stevenson - pg. 232] + //[Ref. 2: http://www.ee.washington.edu/research/real/Library/Reports/Tap_Adjustments_in_AC_Load_Flows.pdf] + //[Ref. 3: http://www.columbia.edu/~dano/courses/power/notes/power/andersson1.pdf] + else { + // Complex turns ratio + double radPhaseShift = wxDegToRad(data.phaseShift); + std::complex a = std::complex(data.turnsRatio * std::cos(radPhaseShift), + -data.turnsRatio * std::sin(radPhaseShift)); + + // Transformer admitance + std::complex y = 1.0 / std::complex(data.resistance, data.indReactance); + + yBus[transfomerMap[transformerNumber][0]][transfomerMap[transformerNumber][0]] += + y / std::pow(std::abs(a), 2.0); + yBus[transfomerMap[transformerNumber][0]][transfomerMap[transformerNumber][1]] += -(y / std::conj(a)); + yBus[transfomerMap[transformerNumber][1]][transfomerMap[transformerNumber][0]] += -(y / a); + yBus[transfomerMap[transformerNumber][1]][transfomerMap[transformerNumber][1]] += y; + } + } + + transformerNumber++; + } + + return true; +} -- cgit From 004257e2abebbf448ba8d1fba32daae216b2c88e Mon Sep 17 00:00:00 2001 From: Thales Lima Oliveira Date: Wed, 2 Nov 2016 23:11:44 -0200 Subject: Gauss-Seidel implemented --- Project/ElectricCalculation.cpp | 16 +++------------- 1 file changed, 3 insertions(+), 13 deletions(-) (limited to 'Project/ElectricCalculation.cpp') diff --git a/Project/ElectricCalculation.cpp b/Project/ElectricCalculation.cpp index 389af4a..5698905 100644 --- a/Project/ElectricCalculation.cpp +++ b/Project/ElectricCalculation.cpp @@ -1,14 +1,4 @@ #include "ElectricCalculation.h" -#include "Element.h" -#include "Bus.h" -#include "Capacitor.h" -#include "IndMotor.h" -#include "Inductor.h" -#include "Line.h" -#include "Load.h" -#include "SyncGenerator.h" -#include "SyncMotor.h" -#include "Transformer.h" ElectricCalculation::ElectricCalculation() {} ElectricCalculation::~ElectricCalculation() {} @@ -89,7 +79,7 @@ bool ElectricCalculation::GetYBus(std::vector > // Load for(auto itlo = m_loadList.begin(); itlo != m_loadList.end(); itlo++) { Load* load = *itlo; - if(bus == load->GetParentList()[0]) { + if(bus == load->GetParentList()[0] && load->IsOnline()) { LoadElectricalData data = load->GetPUElectricalData(systemPowerBase); if(data.loadType == CONST_IMPEDANCE) yBus[busNumber][busNumber] += std::complex(data.activePower, -data.reactivePower); @@ -99,7 +89,7 @@ bool ElectricCalculation::GetYBus(std::vector > // Capacitor for(auto itca = m_capacitorList.begin(); itca != m_capacitorList.end(); itca++) { Capacitor* capacitor = *itca; - if(bus == capacitor->GetParentList()[0]) { + if(bus == capacitor->GetParentList()[0] && capacitor->IsOnline()) { CapacitorElectricalData data = capacitor->GetPUElectricalData(systemPowerBase); yBus[busNumber][busNumber] += std::complex(0.0, data.reactivePower); } @@ -108,7 +98,7 @@ bool ElectricCalculation::GetYBus(std::vector > // Inductor for(auto itin = m_inductorList.begin(); itin != m_inductorList.end(); itin++) { Inductor* inductor = *itin; - if(bus == inductor->GetParentList()[0]) { + if(bus == inductor->GetParentList()[0] && inductor->IsOnline()) { InductorElectricalData data = inductor->GetPUElectricalData(systemPowerBase); yBus[busNumber][busNumber] += std::complex(0.0, -data.reactivePower); } -- cgit From 4799019fb948226daf5777d0d3ba41257dd55657 Mon Sep 17 00:00:00 2001 From: Thales1330 Date: Thu, 3 Nov 2016 16:26:55 -0200 Subject: Power flow validate method under implementation --- Project/ElectricCalculation.cpp | 186 +++++++++++++++++++++++++++++++++++++++- 1 file changed, 184 insertions(+), 2 deletions(-) (limited to 'Project/ElectricCalculation.cpp') diff --git a/Project/ElectricCalculation.cpp b/Project/ElectricCalculation.cpp index 5698905..f018f74 100644 --- a/Project/ElectricCalculation.cpp +++ b/Project/ElectricCalculation.cpp @@ -13,7 +13,7 @@ void ElectricCalculation::GetElementsFromList(std::vector elementList) m_syncGeneratorList.clear(); m_syncMotorList.clear(); m_transformerList.clear(); - // Bad design? + // TODO: Bad design? for(auto it = elementList.begin(); it != elementList.end(); it++) { Element* element = *it; if(typeid(*element) == typeid(Bus)) @@ -79,7 +79,7 @@ bool ElectricCalculation::GetYBus(std::vector > // Load for(auto itlo = m_loadList.begin(); itlo != m_loadList.end(); itlo++) { Load* load = *itlo; - if(bus == load->GetParentList()[0] && load->IsOnline()) { + if(bus == load->GetParentList()[0] && load->IsOnline()) { LoadElectricalData data = load->GetPUElectricalData(systemPowerBase); if(data.loadType == CONST_IMPEDANCE) yBus[busNumber][busNumber] += std::complex(data.activePower, -data.reactivePower); @@ -177,3 +177,185 @@ bool ElectricCalculation::GetYBus(std::vector > return true; } + +void ElectricCalculation::ValidateElementsPowerFlow(std::vector > voltage, + std::vector > power, + double systemPowerBase) +{ + std::vector > lineMap; + std::vector > transfomerMap; + lineMap.resize(m_lineList.size()); + transfomerMap.resize(m_transformerList.size()); + + // Bus voltage and connections maps + for(int i = 0; i < (int)m_busList.size(); i++) { + BusElectricalData data = m_busList[i]->GetEletricalData(); + data.voltage = voltage[i]; + m_busList[i]->SetElectricalData(data); + + // Get power line connection map + for(int j = 0; j < (int)m_lineList.size(); j++) { + for(int k = 0; k < (int)m_lineList[j]->GetParentList().size(); k++) { + if(bus == m_lineList[j]->GetParentList()[k]) lineMap[j].push_back(i); + } + } + + // Get transformer connection map + for(int j = 0; j < (int)m_transformerList.size(); j++) { + for(int k = 0; k < (int)m_transformerList[j]->GetParentList().size(); k++) { + if(bus == m_transformerList[j]->GetParentList()[k]) transfomerMap[j].push_back(i); + } + } + } + + // Power line + for(int i = 0; i < (int)m_lineList.size(); i++) { + if(m_lineList[i]->IsOnline()) { + LineElectricalData data = m_lineList[i]->GetEletricalData(); + std::complex v1 = voltage[lineMap[i][0]]; + std::complex v2 = voltage[lineMap[i][1]]; + + data.current[0] = (v1 - v2) / std::complex(data.resistance, data.indReactance) + + v1 * std::complex(0.0, data.capSusceptance / 2.0); + data.current[1] = (v2 - v1) / std::complex(data.resistance, data.indReactance) + + v2 * std::complex(0.0, data.capSusceptance / 2.0); + + data.powerFlow[0] = v1 * std::conj(data.current[0]); + data.powerFlow[1] = v2 * std::conj(data.current[1]); + + m_lineList[i]->SetElectricalData(data); + } + } + + // Transformer + for(int i = 0; i < (int)m_transformerList.size(); i++) { + if(m_transformerList[i]->IsOnline()) { + TransformerElectricalData data = m_transformerList[i]->GetElectricalData(); + std::complex v1 = voltage[transfomerMap[i][0]]; // Primary voltage + std::complex v2 = voltage[transfomerMap[i][1]]; // Secondary voltage + + // Transformer admitance + std::complex y = 1.0 / std::complex(data.resistance, data.indReactance); + + if(data.turnsRatio == 1.0 && data.phaseShift == 0.0) { + data.current[0] = (v1 - v2) * y; + data.current[1] = (v2 - v1) * y; + } else { + double radPS = wxDegToRad(data.phaseShift); + std::complex a = + std::complex(data.turnsRatio * std::cos(radPS), -data.turnsRatio * std::sin(radPS)); + + data.current[0] = v1 * (y / std::pow(std::abs(a), 2)) - v2 * (y / std::conj(a)); + data.current[1] = -v1 * (y / a) + v2 * y; + } + + data.powerFlow[0] = v1 * std::conj(data.current[0]); + data.powerFlow[1] = v2 * std::conj(data.current[1]); + + m_transformerList[i]->SetElectricalData(data); + } + } + + // Synchronous machines + for(int i = 0; i < (int)m_busList.size(); i++) { + Bus* bus = m_busList[i]; + BusElectricalData data = bus->GetElectricalData(); + + // Get the synchronous machines connected and calculate the load power on the bus. + std::vector syncGeneratorsOnBus; + std::vector syncMotorsOnBus; + std::complex loadPower(0.0, 0.0); + for(auto itsg = m_syncGeneratorList.begin(); itsg != m_syncGeneratorList.end(); itsg++) { + SyncGenerator* syncGenerator = *itsg; + if(bus == syncGenerator->GetParentList()[0]) syncGeneratorsOnBus.push_back(syncGenerator); + } + for(auto itsm = m_syncMotorList.begin(); itsm != m_syncMotorList.end(); itsm++) { + SyncMotor* syncMotor = *itsm; + if(bus == syncMotor->GetParentList()[0]) { + syncMotorsOnBus.push_back(syncMotor); + SyncMotorElectricalData childData = syncMotor->GetPUElectricalData(systemPowerBase); + loadPower += std::complex(childData.activePower, 0.0); + } + } + for(auto itlo = m_loadList.begin(); itlo != m_loadList.end(); itlo++) { + Load* load = itlo; + if(bus == load->GetParentList()[0]) { + LoadElectricalData childData = load->GetPUElectricalData(systemPowerBase); + loadPower += std::complex(childData.activePower, childData.reactivePower); + } + } + for(auto itim = m_indMotorList.begin(); itim != m_indMotorList.end(); itim++) { + IndMotor* indMotor = itim; + if(bus == indMotor->GetParentList()[0]) { + LoadElectricalData childData = indMotor->GetPUElectricalData(systemPowerBase); + if(childData.loadType == CONST_POWER) + loadPower += std::complex(childData.activePower, childData.reactivePower); + else if(childData.loadType == CONST_IMPEDANCE) + loadPower += std::pow(std::abs(voltage[i]), 2) * + std::complex(childData.activePower, childData.reactivePower); + } + } + for(auto itim = m_indMotorList.begin(); itim != m_indMotorList.end(); itim++) { + IndMotor* indMotor = itim; + if(bus == indMotor->GetParentList()[0]) { + IndMotorElectricalData childData = indMotor->GetPUElectricalData(systemPowerBase); + loadPower += std::complex(childData.activePower, childData.reactivePower); + } + } + for(auto itca = m_capacitorList.begin(); itca != m_capacitorList.end(); itca++) { + Capacitor* capacitor = itca; + if(bus == capacitor->GetParentList()[0]) { + CapacitorElectricalData childData = capacitor->GetPUElectricalData(systemPowerBase); + loadPower += std::pow(std::abs(voltage[i]), 2) * std::complex(0.0, -childData.reactivePower); + } + } + for(auto itin = m_capacitorList.begin(); itin != m_capacitorList.end(); itin++) { + Inductor* inductor = itin; + if(bus == inductor->GetParentList()[0]) { + InductorElectricalData childData = inductor->GetPUElectricalData(systemPowerBase); + loadPower += std::pow(std::abs(voltage[i]), 2) * std::complex(0.0, childData.reactivePower); + } + } + + // Set the sync generator power + for(auto itsg = syncGeneratorsOnBus.begin(); itsg != syncGeneratorsOnBus.end(); itsg++) { + SyncGenerator* generator = *itsg; + SyncGeneratorElectricalData childData = generator->GetElectricalData(); + + if(data.slackBus) { + double activePower = + (power[i].real() + loadPower.real()) * systemPowerBase / (double)(syncGeneratorsOnBus.size()); + + switch(childData.activePowerUnit) { + case UNIT_kW: { + activePower /= 1e3; + } break; + case UNIT_MW: { + activePower /= 1e6; + } break; + default: break; + } + childData.activePower = activePower; + } + double reactivePower = (power[i].imag() + loadPower.imag()) * systemPowerBase / + (double)(syncGeneratorsOnBus.size() + syncMotorsOnBus.size()); + switch(childData.reactivePowerUnit) { + case UNIT_kVAr: { + reactivePower /= 1e3; + } break; + case UNIT_MVAr: { + reactivePower /= 1e6; + } break; + default: break; + } + childData.reactivePower = reactivePower; + + generator->SetElectricalData(childData); + } + + // continua... + // falta o compensador sincrono + // verificar se eh necessario os tipos de barra nesse metodo. + // Tavez soh pode mudar a potencia reative em maquinas conectadas em barras PV?? --> TESTAR + } +} -- cgit From 9919f24692c1fe9b8e11fde5c6d5c18f169b5c10 Mon Sep 17 00:00:00 2001 From: Thales1330 Date: Fri, 4 Nov 2016 18:02:03 -0200 Subject: Validation implemented --- Project/ElectricCalculation.cpp | 357 ++++++++++++++++++++-------------------- 1 file changed, 178 insertions(+), 179 deletions(-) (limited to 'Project/ElectricCalculation.cpp') diff --git a/Project/ElectricCalculation.cpp b/Project/ElectricCalculation.cpp index f018f74..3cda1af 100644 --- a/Project/ElectricCalculation.cpp +++ b/Project/ElectricCalculation.cpp @@ -51,104 +51,85 @@ bool ElectricCalculation::GetYBus(std::vector > yBus.push_back(line); } - // Build connection map - std::vector > lineMap; - std::vector > transfomerMap; - lineMap.resize(m_lineList.size()); - transfomerMap.resize(m_transformerList.size()); - - // Get the connection map for + // Set buses numbers int busNumber = 0; for(auto itb = m_busList.begin(); itb != m_busList.end(); itb++) { Bus* bus = *itb; + BusElectricalData data = bus->GetEletricalData(); + data.number = busNumber; + bus->SetElectricalData(data); + busNumber++; + } - // Get power line connection map - for(int i = 0; i < (int)m_lineList.size(); i++) { - for(int j = 0; j < (int)m_lineList[i]->GetParentList().size(); j++) { - if(bus == m_lineList[i]->GetParentList()[j]) lineMap[i].push_back(busNumber); - } - } - - // Get transformer connection map - for(int i = 0; i < (int)m_transformerList.size(); i++) { - for(int j = 0; j < (int)m_transformerList[i]->GetParentList().size(); j++) { - if(bus == m_transformerList[i]->GetParentList()[j]) transfomerMap[i].push_back(busNumber); - } - } - - // Load - for(auto itlo = m_loadList.begin(); itlo != m_loadList.end(); itlo++) { - Load* load = *itlo; - if(bus == load->GetParentList()[0] && load->IsOnline()) { - LoadElectricalData data = load->GetPUElectricalData(systemPowerBase); - if(data.loadType == CONST_IMPEDANCE) - yBus[busNumber][busNumber] += std::complex(data.activePower, -data.reactivePower); - } + // Load + for(auto itlo = m_loadList.begin(); itlo != m_loadList.end(); itlo++) { + Load* load = *itlo; + if(load->IsOnline()) { + int n = ((Bus*)load->GetParentList()[0])->GetEletricalData().number; + LoadElectricalData data = load->GetPUElectricalData(systemPowerBase); + if(data.loadType == CONST_IMPEDANCE) + yBus[n][n] += std::complex(data.activePower, -data.reactivePower); } + } - // Capacitor - for(auto itca = m_capacitorList.begin(); itca != m_capacitorList.end(); itca++) { - Capacitor* capacitor = *itca; - if(bus == capacitor->GetParentList()[0] && capacitor->IsOnline()) { - CapacitorElectricalData data = capacitor->GetPUElectricalData(systemPowerBase); - yBus[busNumber][busNumber] += std::complex(0.0, data.reactivePower); - } + // Capacitor + for(auto itca = m_capacitorList.begin(); itca != m_capacitorList.end(); itca++) { + Capacitor* capacitor = *itca; + if(capacitor->IsOnline()) { + int n = ((Bus*)capacitor->GetParentList()[0])->GetEletricalData().number; + CapacitorElectricalData data = capacitor->GetPUElectricalData(systemPowerBase); + yBus[n][n] += std::complex(0.0, data.reactivePower); } + } - // Inductor - for(auto itin = m_inductorList.begin(); itin != m_inductorList.end(); itin++) { - Inductor* inductor = *itin; - if(bus == inductor->GetParentList()[0] && inductor->IsOnline()) { - InductorElectricalData data = inductor->GetPUElectricalData(systemPowerBase); - yBus[busNumber][busNumber] += std::complex(0.0, -data.reactivePower); - } + // Inductor + for(auto itin = m_inductorList.begin(); itin != m_inductorList.end(); itin++) { + Inductor* inductor = *itin; + if(inductor->IsOnline()) { + int n = ((Bus*)inductor->GetParentList()[0])->GetEletricalData().number; + InductorElectricalData data = inductor->GetPUElectricalData(systemPowerBase); + yBus[n][n] += std::complex(0.0, -data.reactivePower); } - - busNumber++; } // Power line - int lineNumber = 0; for(auto itl = m_lineList.begin(); itl != m_lineList.end(); itl++) { Line* line = *itl; - LineElectricalData data = line->GetElectricalData(); if(line->IsOnline()) { - yBus[lineMap[lineNumber][0]][lineMap[lineNumber][1]] -= - 1.0 / std::complex(data.resistance, data.indReactance); - yBus[lineMap[lineNumber][1]][lineMap[lineNumber][0]] -= - 1.0 / std::complex(data.resistance, data.indReactance); - - yBus[lineMap[lineNumber][0]][lineMap[lineNumber][0]] += - 1.0 / std::complex(data.resistance, data.indReactance); - yBus[lineMap[lineNumber][1]][lineMap[lineNumber][1]] += - 1.0 / std::complex(data.resistance, data.indReactance); - - yBus[lineMap[lineNumber][0]][lineMap[lineNumber][0]] += - std::complex(0.0, data.capSusceptance / 2.0); - yBus[lineMap[lineNumber][1]][lineMap[lineNumber][1]] += - std::complex(0.0, data.capSusceptance / 2.0); + LineElectricalData data = line->GetElectricalData(); + + int n1 = ((Bus*)line->GetParentList()[0])->GetEletricalData().number; + int n2 = ((Bus*)line->GetParentList()[1])->GetEletricalData().number; + + yBus[n1][n2] -= 1.0 / std::complex(data.resistance, data.indReactance); + yBus[n2][n1] -= 1.0 / std::complex(data.resistance, data.indReactance); + + yBus[n1][n1] += 1.0 / std::complex(data.resistance, data.indReactance); + yBus[n2][n2] += 1.0 / std::complex(data.resistance, data.indReactance); + + yBus[n1][n1] += std::complex(0.0, data.capSusceptance / 2.0); + yBus[n2][n2] += std::complex(0.0, data.capSusceptance / 2.0); } - lineNumber++; } - int transformerNumber = 0; + // Transformer for(auto itt = m_transformerList.begin(); itt != m_transformerList.end(); ++itt) { Transformer* transformer = *itt; - TransformerElectricalData data = transformer->GetElectricalData(); if(transformer->IsOnline()) { + TransformerElectricalData data = transformer->GetElectricalData(); + + int n1 = ((Bus*)transformer->GetParentList()[0])->GetEletricalData().number; + int n2 = ((Bus*)transformer->GetParentList()[1])->GetEletricalData().number; + // If the transformer have nominal turns ratio (1.0) and no phase shifting, it will be modelled as series // impedance. if(data.turnsRatio == 1.0 && data.phaseShift == 0.0) { - yBus[transfomerMap[transformerNumber][0]][transfomerMap[transformerNumber][1]] += - -1.0 / std::complex(data.resistance, data.indReactance); - yBus[transfomerMap[transformerNumber][1]][transfomerMap[transformerNumber][0]] += - -1.0 / std::complex(data.resistance, data.indReactance); - - yBus[transfomerMap[transformerNumber][0]][transfomerMap[transformerNumber][0]] += - 1.0 / std::complex(data.resistance, data.indReactance); - yBus[transfomerMap[transformerNumber][1]][transfomerMap[transformerNumber][1]] += - 1.0 / std::complex(data.resistance, data.indReactance); + yBus[n1][n2] += -1.0 / std::complex(data.resistance, data.indReactance); + yBus[n2][n1] += -1.0 / std::complex(data.resistance, data.indReactance); + + yBus[n1][n1] += 1.0 / std::complex(data.resistance, data.indReactance); + yBus[n2][n2] += 1.0 / std::complex(data.resistance, data.indReactance); } // If the transformer have no-nominal turn ratio and/or phase shifting, it will be modelled in a different // way (see references). @@ -164,15 +145,12 @@ bool ElectricCalculation::GetYBus(std::vector > // Transformer admitance std::complex y = 1.0 / std::complex(data.resistance, data.indReactance); - yBus[transfomerMap[transformerNumber][0]][transfomerMap[transformerNumber][0]] += - y / std::pow(std::abs(a), 2.0); - yBus[transfomerMap[transformerNumber][0]][transfomerMap[transformerNumber][1]] += -(y / std::conj(a)); - yBus[transfomerMap[transformerNumber][1]][transfomerMap[transformerNumber][0]] += -(y / a); - yBus[transfomerMap[transformerNumber][1]][transfomerMap[transformerNumber][1]] += y; + yBus[n1][n1] += y / std::pow(std::abs(a), 2.0); + yBus[n1][n2] += -(y / std::conj(a)); + yBus[n2][n1] += -(y / a); + yBus[n2][n2] += y; } } - - transformerNumber++; } return true; @@ -180,40 +158,27 @@ bool ElectricCalculation::GetYBus(std::vector > void ElectricCalculation::ValidateElementsPowerFlow(std::vector > voltage, std::vector > power, + std::vector busType, double systemPowerBase) { - std::vector > lineMap; - std::vector > transfomerMap; - lineMap.resize(m_lineList.size()); - transfomerMap.resize(m_transformerList.size()); - - // Bus voltage and connections maps + // Buses voltages for(int i = 0; i < (int)m_busList.size(); i++) { - BusElectricalData data = m_busList[i]->GetEletricalData(); + Bus* bus = m_busList[i]; + BusElectricalData data = bus->GetEletricalData(); data.voltage = voltage[i]; - m_busList[i]->SetElectricalData(data); - - // Get power line connection map - for(int j = 0; j < (int)m_lineList.size(); j++) { - for(int k = 0; k < (int)m_lineList[j]->GetParentList().size(); k++) { - if(bus == m_lineList[j]->GetParentList()[k]) lineMap[j].push_back(i); - } - } - - // Get transformer connection map - for(int j = 0; j < (int)m_transformerList.size(); j++) { - for(int k = 0; k < (int)m_transformerList[j]->GetParentList().size(); k++) { - if(bus == m_transformerList[j]->GetParentList()[k]) transfomerMap[j].push_back(i); - } - } + bus->SetElectricalData(data); } // Power line for(int i = 0; i < (int)m_lineList.size(); i++) { - if(m_lineList[i]->IsOnline()) { - LineElectricalData data = m_lineList[i]->GetEletricalData(); - std::complex v1 = voltage[lineMap[i][0]]; - std::complex v2 = voltage[lineMap[i][1]]; + Line* line = m_lineList[i]; + if(line->IsOnline()) { + int n1 = ((Bus*)line->GetParentList()[0])->GetEletricalData().number; + int n2 = ((Bus*)line->GetParentList()[1])->GetEletricalData().number; + + LineElectricalData data = line->GetElectricalData(); + std::complex v1 = voltage[n1]; + std::complex v2 = voltage[n2]; data.current[0] = (v1 - v2) / std::complex(data.resistance, data.indReactance) + v1 * std::complex(0.0, data.capSusceptance / 2.0); @@ -223,16 +188,24 @@ void ElectricCalculation::ValidateElementsPowerFlow(std::vectorSetElectricalData(data); + if(data.powerFlow[0].real() > data.powerFlow[1].real()) + line->SetPowerFlowDirection(PF_BUS1_TO_BUS2); + else + line->SetPowerFlowDirection(PF_BUS2_TO_BUS1); + + line->SetElectricalData(data); } } // Transformer for(int i = 0; i < (int)m_transformerList.size(); i++) { - if(m_transformerList[i]->IsOnline()) { - TransformerElectricalData data = m_transformerList[i]->GetElectricalData(); - std::complex v1 = voltage[transfomerMap[i][0]]; // Primary voltage - std::complex v2 = voltage[transfomerMap[i][1]]; // Secondary voltage + Transformer* transformer = m_transformerList[i]; + if(transformer->IsOnline()) { + TransformerElectricalData data = transformer->GetElectricalData(); + int n1 = ((Bus*)transformer->GetParentList()[0])->GetEletricalData().number; + int n2 = ((Bus*)transformer->GetParentList()[1])->GetEletricalData().number; + std::complex v1 = voltage[n1]; // Primary voltage + std::complex v2 = voltage[n2]; // Secondary voltage // Transformer admitance std::complex y = 1.0 / std::complex(data.resistance, data.indReactance); @@ -252,14 +225,19 @@ void ElectricCalculation::ValidateElementsPowerFlow(std::vectorSetElectricalData(data); + if(data.powerFlow[0].real() > data.powerFlow[1].real()) + transformer->SetPowerFlowDirection(PF_BUS1_TO_BUS2); + else + transformer->SetPowerFlowDirection(PF_BUS2_TO_BUS1); + + transformer->SetElectricaData(data); } } // Synchronous machines for(int i = 0; i < (int)m_busList.size(); i++) { Bus* bus = m_busList[i]; - BusElectricalData data = bus->GetElectricalData(); + BusElectricalData data = bus->GetEletricalData(); // Get the synchronous machines connected and calculate the load power on the bus. std::vector syncGeneratorsOnBus; @@ -267,95 +245,116 @@ void ElectricCalculation::ValidateElementsPowerFlow(std::vector loadPower(0.0, 0.0); for(auto itsg = m_syncGeneratorList.begin(); itsg != m_syncGeneratorList.end(); itsg++) { SyncGenerator* syncGenerator = *itsg; - if(bus == syncGenerator->GetParentList()[0]) syncGeneratorsOnBus.push_back(syncGenerator); + if(bus == syncGenerator->GetParentList()[0] && syncGenerator->IsOnline()) + syncGeneratorsOnBus.push_back(syncGenerator); } for(auto itsm = m_syncMotorList.begin(); itsm != m_syncMotorList.end(); itsm++) { SyncMotor* syncMotor = *itsm; - if(bus == syncMotor->GetParentList()[0]) { + if(bus == syncMotor->GetParentList()[0] && syncMotor->IsOnline()) { syncMotorsOnBus.push_back(syncMotor); SyncMotorElectricalData childData = syncMotor->GetPUElectricalData(systemPowerBase); loadPower += std::complex(childData.activePower, 0.0); } } for(auto itlo = m_loadList.begin(); itlo != m_loadList.end(); itlo++) { - Load* load = itlo; - if(bus == load->GetParentList()[0]) { + Load* load = *itlo; + if(bus == load->GetParentList()[0] && load->IsOnline()) { LoadElectricalData childData = load->GetPUElectricalData(systemPowerBase); - loadPower += std::complex(childData.activePower, childData.reactivePower); - } - } - for(auto itim = m_indMotorList.begin(); itim != m_indMotorList.end(); itim++) { - IndMotor* indMotor = itim; - if(bus == indMotor->GetParentList()[0]) { - LoadElectricalData childData = indMotor->GetPUElectricalData(systemPowerBase); if(childData.loadType == CONST_POWER) loadPower += std::complex(childData.activePower, childData.reactivePower); - else if(childData.loadType == CONST_IMPEDANCE) - loadPower += std::pow(std::abs(voltage[i]), 2) * - std::complex(childData.activePower, childData.reactivePower); } } for(auto itim = m_indMotorList.begin(); itim != m_indMotorList.end(); itim++) { - IndMotor* indMotor = itim; - if(bus == indMotor->GetParentList()[0]) { + IndMotor* indMotor = *itim; + if(bus == indMotor->GetParentList()[0] && indMotor->IsOnline()) { IndMotorElectricalData childData = indMotor->GetPUElectricalData(systemPowerBase); loadPower += std::complex(childData.activePower, childData.reactivePower); } } - for(auto itca = m_capacitorList.begin(); itca != m_capacitorList.end(); itca++) { - Capacitor* capacitor = itca; - if(bus == capacitor->GetParentList()[0]) { - CapacitorElectricalData childData = capacitor->GetPUElectricalData(systemPowerBase); - loadPower += std::pow(std::abs(voltage[i]), 2) * std::complex(0.0, -childData.reactivePower); - } - } - for(auto itin = m_capacitorList.begin(); itin != m_capacitorList.end(); itin++) { - Inductor* inductor = itin; - if(bus == inductor->GetParentList()[0]) { - InductorElectricalData childData = inductor->GetPUElectricalData(systemPowerBase); - loadPower += std::pow(std::abs(voltage[i]), 2) * std::complex(0.0, childData.reactivePower); - } - } - + // Set the sync generator power - for(auto itsg = syncGeneratorsOnBus.begin(); itsg != syncGeneratorsOnBus.end(); itsg++) { - SyncGenerator* generator = *itsg; - SyncGeneratorElectricalData childData = generator->GetElectricalData(); - - if(data.slackBus) { - double activePower = - (power[i].real() + loadPower.real()) * systemPowerBase / (double)(syncGeneratorsOnBus.size()); - - switch(childData.activePowerUnit) { - case UNIT_kW: { - activePower /= 1e3; - } break; - case UNIT_MW: { - activePower /= 1e6; - } break; - default: break; + if(busType[i] == BUS_SLACK || busType[i] == BUS_PV) { + for(auto itsg = syncGeneratorsOnBus.begin(); itsg != syncGeneratorsOnBus.end(); itsg++) { + SyncGenerator* generator = *itsg; + if(generator->IsOnline()) { + SyncGeneratorElectricalData childData = generator->GetElectricalData(); + + if(busType[i] == BUS_SLACK) { + double activePower = (power[i].real() + loadPower.real()) * systemPowerBase / + (double)(syncGeneratorsOnBus.size()); + + switch(childData.activePowerUnit) { + case UNIT_PU: { + activePower /= systemPowerBase; + } break; + case UNIT_kW: { + activePower /= 1e3; + } break; + case UNIT_MW: { + activePower /= 1e6; + } break; + default: + break; + } + + if(activePower >= 0.0) + generator->SetPowerFlowDirection(PF_TO_BUS); + else + generator->SetPowerFlowDirection(PF_TO_ELEMENT); + + childData.activePower = activePower; + } + if(busType[i] == BUS_PV || busType[i] == BUS_SLACK) { + double reactivePower = (power[i].imag() + loadPower.imag()) * systemPowerBase / + (double)(syncGeneratorsOnBus.size() + syncMotorsOnBus.size()); + switch(childData.reactivePowerUnit) { + case UNIT_PU: { + reactivePower /= systemPowerBase; + } break; + case UNIT_kVAr: { + reactivePower /= 1e3; + } break; + case UNIT_MVAr: { + reactivePower /= 1e6; + } break; + default: + break; + } + childData.reactivePower = reactivePower; + } + + generator->SetElectricalData(childData); } - childData.activePower = activePower; } - double reactivePower = (power[i].imag() + loadPower.imag()) * systemPowerBase / - (double)(syncGeneratorsOnBus.size() + syncMotorsOnBus.size()); - switch(childData.reactivePowerUnit) { - case UNIT_kVAr: { - reactivePower /= 1e3; - } break; - case UNIT_MVAr: { - reactivePower /= 1e6; - } break; - default: break; + } + + // Set the sync motor reactive power + if(busType[i] == BUS_PV) { + for(auto itmg = syncMotorsOnBus.begin(); itmg != syncMotorsOnBus.end(); itmg++) { + SyncMotor* syncMotor = *itmg; + if(syncMotor->IsOnline()) { + SyncMotorElectricalData childData = syncMotor->GetElectricalData(); + + double reactivePower = (power[i].imag() + loadPower.imag()) * systemPowerBase / + (double)(syncGeneratorsOnBus.size() + syncMotorsOnBus.size()); + switch(childData.reactivePowerUnit) { + case UNIT_PU: { + reactivePower /= systemPowerBase; + } break; + case UNIT_kVAr: { + reactivePower /= 1e3; + } break; + case UNIT_MVAr: { + reactivePower /= 1e6; + } break; + default: + break; + } + childData.reactivePower = reactivePower; + + syncMotor->SetElectricalData(childData); + } } - childData.reactivePower = reactivePower; - - generator->SetElectricalData(childData); } - - // continua... - // falta o compensador sincrono - // verificar se eh necessario os tipos de barra nesse metodo. - // Tavez soh pode mudar a potencia reative em maquinas conectadas em barras PV?? --> TESTAR } } -- cgit From b6d4815859b494cc6e5e1f1718a3b410fdd6037a Mon Sep 17 00:00:00 2001 From: Thales1330 Date: Mon, 7 Nov 2016 17:23:07 -0200 Subject: Reactive limits under implementation --- Project/ElectricCalculation.cpp | 133 ++++++++++++++++++++++------------------ 1 file changed, 73 insertions(+), 60 deletions(-) (limited to 'Project/ElectricCalculation.cpp') diff --git a/Project/ElectricCalculation.cpp b/Project/ElectricCalculation.cpp index 3cda1af..a68cc19 100644 --- a/Project/ElectricCalculation.cpp +++ b/Project/ElectricCalculation.cpp @@ -156,10 +156,10 @@ bool ElectricCalculation::GetYBus(std::vector > return true; } -void ElectricCalculation::ValidateElementsPowerFlow(std::vector > voltage, - std::vector > power, - std::vector busType, - double systemPowerBase) +void ElectricCalculation::UpdateElementsPowerFlow(std::vector > voltage, + std::vector > power, + std::vector busType, + double systemPowerBase) { // Buses voltages for(int i = 0; i < (int)m_busList.size(); i++) { @@ -262,6 +262,11 @@ void ElectricCalculation::ValidateElementsPowerFlow(std::vectorGetPUElectricalData(systemPowerBase); if(childData.loadType == CONST_POWER) loadPower += std::complex(childData.activePower, childData.reactivePower); + + if(childData.activePower >= 0.0) + load->SetPowerFlowDirection(PF_TO_ELEMENT); + else + load->SetPowerFlowDirection(PF_TO_BUS); } } for(auto itim = m_indMotorList.begin(); itim != m_indMotorList.end(); itim++) { @@ -269,72 +274,75 @@ void ElectricCalculation::ValidateElementsPowerFlow(std::vectorGetParentList()[0] && indMotor->IsOnline()) { IndMotorElectricalData childData = indMotor->GetPUElectricalData(systemPowerBase); loadPower += std::complex(childData.activePower, childData.reactivePower); + + if(childData.activePower >= 0.0) + indMotor->SetPowerFlowDirection(PF_TO_ELEMENT); + else + indMotor->SetPowerFlowDirection(PF_TO_BUS); } } // Set the sync generator power - if(busType[i] == BUS_SLACK || busType[i] == BUS_PV) { - for(auto itsg = syncGeneratorsOnBus.begin(); itsg != syncGeneratorsOnBus.end(); itsg++) { - SyncGenerator* generator = *itsg; - if(generator->IsOnline()) { - SyncGeneratorElectricalData childData = generator->GetElectricalData(); - - if(busType[i] == BUS_SLACK) { - double activePower = (power[i].real() + loadPower.real()) * systemPowerBase / - (double)(syncGeneratorsOnBus.size()); - - switch(childData.activePowerUnit) { - case UNIT_PU: { - activePower /= systemPowerBase; - } break; - case UNIT_kW: { - activePower /= 1e3; - } break; - case UNIT_MW: { - activePower /= 1e6; - } break; - default: - break; - } - - if(activePower >= 0.0) - generator->SetPowerFlowDirection(PF_TO_BUS); - else - generator->SetPowerFlowDirection(PF_TO_ELEMENT); - - childData.activePower = activePower; - } - if(busType[i] == BUS_PV || busType[i] == BUS_SLACK) { - double reactivePower = (power[i].imag() + loadPower.imag()) * systemPowerBase / - (double)(syncGeneratorsOnBus.size() + syncMotorsOnBus.size()); - switch(childData.reactivePowerUnit) { - case UNIT_PU: { - reactivePower /= systemPowerBase; - } break; - case UNIT_kVAr: { - reactivePower /= 1e3; - } break; - case UNIT_MVAr: { - reactivePower /= 1e6; - } break; - default: - break; - } - childData.reactivePower = reactivePower; + for(auto itsg = syncGeneratorsOnBus.begin(); itsg != syncGeneratorsOnBus.end(); itsg++) { + SyncGenerator* generator = *itsg; + if(generator->IsOnline()) { + SyncGeneratorElectricalData childData = generator->GetElectricalData(); + + if(busType[i] == BUS_SLACK) { + double activePower = + (power[i].real() + loadPower.real()) * systemPowerBase / (double)(syncGeneratorsOnBus.size()); + + switch(childData.activePowerUnit) { + case UNIT_PU: { + activePower /= systemPowerBase; + } break; + case UNIT_kW: { + activePower /= 1e3; + } break; + case UNIT_MW: { + activePower /= 1e6; + } break; + default: + break; } - generator->SetElectricalData(childData); + childData.activePower = activePower; } + if(busType[i] == BUS_PV || busType[i] == BUS_SLACK) { + double reactivePower = (power[i].imag() + loadPower.imag()) * systemPowerBase / + (double)(syncGeneratorsOnBus.size() + syncMotorsOnBus.size()); + switch(childData.reactivePowerUnit) { + case UNIT_PU: { + reactivePower /= systemPowerBase; + } break; + case UNIT_kVAr: { + reactivePower /= 1e3; + } break; + case UNIT_MVAr: { + reactivePower /= 1e6; + } break; + default: + break; + } + childData.reactivePower = reactivePower; + } + + if(childData.activePower >= 0.0) + generator->SetPowerFlowDirection(PF_TO_BUS); + else + generator->SetPowerFlowDirection(PF_TO_ELEMENT); + + generator->SetElectricalData(childData); } } // Set the sync motor reactive power - if(busType[i] == BUS_PV) { - for(auto itmg = syncMotorsOnBus.begin(); itmg != syncMotorsOnBus.end(); itmg++) { - SyncMotor* syncMotor = *itmg; - if(syncMotor->IsOnline()) { - SyncMotorElectricalData childData = syncMotor->GetElectricalData(); + for(auto itmg = syncMotorsOnBus.begin(); itmg != syncMotorsOnBus.end(); itmg++) { + SyncMotor* syncMotor = *itmg; + if(syncMotor->IsOnline()) { + SyncMotorElectricalData childData = syncMotor->GetElectricalData(); + if(busType[i] == BUS_PV || busType[i] == BUS_SLACK) { double reactivePower = (power[i].imag() + loadPower.imag()) * systemPowerBase / (double)(syncGeneratorsOnBus.size() + syncMotorsOnBus.size()); switch(childData.reactivePowerUnit) { @@ -351,9 +359,14 @@ void ElectricCalculation::ValidateElementsPowerFlow(std::vectorSetElectricalData(childData); } + + if(childData.activePower > 0.0) + syncMotor->SetPowerFlowDirection(PF_TO_ELEMENT); + else + syncMotor->SetPowerFlowDirection(PF_TO_BUS); + + syncMotor->SetElectricalData(childData); } } } -- cgit From e49af3edd77a3494ff255c45eeee85bd8b287737 Mon Sep 17 00:00:00 2001 From: Thales1330 Date: Wed, 9 Nov 2016 17:38:02 -0200 Subject: Fixing reactive generation limit [2] --- Project/ElectricCalculation.cpp | 39 +++++++++++++++++++++++++++++++++++---- 1 file changed, 35 insertions(+), 4 deletions(-) (limited to 'Project/ElectricCalculation.cpp') diff --git a/Project/ElectricCalculation.cpp b/Project/ElectricCalculation.cpp index a68cc19..569a31e 100644 --- a/Project/ElectricCalculation.cpp +++ b/Project/ElectricCalculation.cpp @@ -159,6 +159,7 @@ bool ElectricCalculation::GetYBus(std::vector > void ElectricCalculation::UpdateElementsPowerFlow(std::vector > voltage, std::vector > power, std::vector busType, + std::vector reactiveLimit, double systemPowerBase) { // Buses voltages @@ -243,6 +244,7 @@ void ElectricCalculation::UpdateElementsPowerFlow(std::vector syncGeneratorsOnBus; std::vector syncMotorsOnBus; std::complex loadPower(0.0, 0.0); + for(auto itsg = m_syncGeneratorList.begin(); itsg != m_syncGeneratorList.end(); itsg++) { SyncGenerator* syncGenerator = *itsg; if(bus == syncGenerator->GetParentList()[0] && syncGenerator->IsOnline()) @@ -309,8 +311,21 @@ void ElectricCalculation::UpdateElementsPowerFlow(std::vectorGetPUElectricalData(systemPowerBase); + + double reactivePower = (power[i].imag() + loadPower.imag()) * systemPowerBase; + + if(reactiveLimit[i].limitReached == RL_MAX_REACHED) + reactivePower *= (childData_PU.maxReactive / reactiveLimit[i].maxLimit); + + else if(reactiveLimit[i].limitReached == RL_MIN_REACHED) + reactivePower *= (childData_PU.minReactive / reactiveLimit[i].minLimit); + + else + reactivePower /= (double)(syncGeneratorsOnBus.size() + syncMotorsOnBus.size()); + switch(childData.reactivePowerUnit) { case UNIT_PU: { reactivePower /= systemPowerBase; @@ -343,8 +358,24 @@ void ElectricCalculation::UpdateElementsPowerFlow(std::vectorGetElectricalData(); if(busType[i] == BUS_PV || busType[i] == BUS_SLACK) { - double reactivePower = (power[i].imag() + loadPower.imag()) * systemPowerBase / - (double)(syncGeneratorsOnBus.size() + syncMotorsOnBus.size()); + // double reactivePower = (power[i].imag() + loadPower.imag()) * systemPowerBase / + // (double)(syncGeneratorsOnBus.size() + syncMotorsOnBus.size()); + + SyncMotorElectricalData childData_PU = syncMotor->GetPUElectricalData(systemPowerBase); + + double reactivePower = (power[i].imag() + loadPower.imag()) * systemPowerBase; + + // Bus reachd maximum reactive limit. + if(reactiveLimit[i].limitReached == RL_MAX_REACHED) + reactivePower *= (childData_PU.maxReactive / reactiveLimit[i].maxLimit); + // Bus reached minimum reactive limit. + else if(reactiveLimit[i].limitReached == RL_MIN_REACHED) + reactivePower *= (childData_PU.minReactive / reactiveLimit[i].minLimit); + // Bus didn't reach any limits + else { + reactivePower /= (double)(syncGeneratorsOnBus.size() + syncMotorsOnBus.size()); + } + switch(childData.reactivePowerUnit) { case UNIT_PU: { reactivePower /= systemPowerBase; -- cgit From 8d78d8c052550b9efc1a7de39aa4b776be002396 Mon Sep 17 00:00:00 2001 From: Thales1330 Date: Fri, 11 Nov 2016 17:54:42 -0200 Subject: Last commit not solved yet --- Project/ElectricCalculation.cpp | 105 ++++++++++++++++++++++++---------------- 1 file changed, 64 insertions(+), 41 deletions(-) (limited to 'Project/ElectricCalculation.cpp') diff --git a/Project/ElectricCalculation.cpp b/Project/ElectricCalculation.cpp index 569a31e..3c4c1e5 100644 --- a/Project/ElectricCalculation.cpp +++ b/Project/ElectricCalculation.cpp @@ -352,52 +352,75 @@ void ElectricCalculation::UpdateElementsPowerFlow(std::vectorIsOnline()) { - SyncMotorElectricalData childData = syncMotor->GetElectricalData(); - - if(busType[i] == BUS_PV || busType[i] == BUS_SLACK) { - // double reactivePower = (power[i].imag() + loadPower.imag()) * systemPowerBase / - // (double)(syncGeneratorsOnBus.size() + syncMotorsOnBus.size()); - - SyncMotorElectricalData childData_PU = syncMotor->GetPUElectricalData(systemPowerBase); - - double reactivePower = (power[i].imag() + loadPower.imag()) * systemPowerBase; - - // Bus reachd maximum reactive limit. - if(reactiveLimit[i].limitReached == RL_MAX_REACHED) - reactivePower *= (childData_PU.maxReactive / reactiveLimit[i].maxLimit); - // Bus reached minimum reactive limit. - else if(reactiveLimit[i].limitReached == RL_MIN_REACHED) - reactivePower *= (childData_PU.minReactive / reactiveLimit[i].minLimit); - // Bus didn't reach any limits - else { - reactivePower /= (double)(syncGeneratorsOnBus.size() + syncMotorsOnBus.size()); + double exceededReactive = 0.0; + int numMachines = syncGeneratorsOnBus.size() + syncMotorsOnBus.size(); + for(auto itsm = syncMotorsOnBus.begin(); itsm != syncMotorsOnBus.end(); itsm++) { + SyncMotor* syncMotor = *itsm; + SyncMotorElectricalData childData = syncMotor->GetElectricalData(); + + bool reachedMachineLimit = false; + + if(busType[i] == BUS_PV || busType[i] == BUS_SLACK) { + // double reactivePower = (power[i].imag() + loadPower.imag()) * systemPowerBase / + // (double)(syncGeneratorsOnBus.size() + syncMotorsOnBus.size()); + + SyncMotorElectricalData childData_PU = syncMotor->GetPUElectricalData(systemPowerBase); + + double reactivePower = power[i].imag() + loadPower.imag(); + + // Bus reachd maximum reactive limit. + if(reactiveLimit[i].limitReached == RL_MAX_REACHED) + reactivePower *= (childData_PU.maxReactive / reactiveLimit[i].maxLimit); + // Bus reached minimum reactive limit. + else if(reactiveLimit[i].limitReached == RL_MIN_REACHED) + reactivePower *= (childData_PU.minReactive / reactiveLimit[i].minLimit); + // Bus didn't reach any limits + else { + reactivePower /= (double)(numMachines); + if(childData_PU.haveMaxReactive && (reactivePower > childData_PU.maxReactive)) { + exceededReactive += reactivePower - childData_PU.maxReactive; + reactivePower = childData_PU.maxReactive; + reachedMachineLimit = true; + } else if(childData_PU.haveMinReactive && (reactivePower < childData_PU.minReactive)) { + exceededReactive += reactivePower - childData_PU.minReactive; + reactivePower = childData_PU.minReactive; + reachedMachineLimit = true; + } else if((!childData_PU.haveMaxReactive && reactiveLimit[i].limitReached == RL_MAX_REACHED) || + (!childData_PU.haveMinReactive && reactiveLimit[i].limitReached == RL_MIN_REACHED) || + (!childData_PU.haveMaxReactive && !childData_PU.haveMaxReactive)) { + reactivePower += exceededReactive; + exceededReactive = 0.0; } + } - switch(childData.reactivePowerUnit) { - case UNIT_PU: { - reactivePower /= systemPowerBase; - } break; - case UNIT_kVAr: { - reactivePower /= 1e3; - } break; - case UNIT_MVAr: { - reactivePower /= 1e6; - } break; - default: - break; - } - childData.reactivePower = reactivePower; + reactivePower *= systemPowerBase; + + switch(childData.reactivePowerUnit) { + case UNIT_PU: { + reactivePower /= systemPowerBase; + } break; + case UNIT_kVAr: { + reactivePower /= 1e3; + } break; + case UNIT_MVAr: { + reactivePower /= 1e6; + } break; + default: + break; } + childData.reactivePower = reactivePower; + } - if(childData.activePower > 0.0) - syncMotor->SetPowerFlowDirection(PF_TO_ELEMENT); - else - syncMotor->SetPowerFlowDirection(PF_TO_BUS); + if(childData.activePower > 0.0) + syncMotor->SetPowerFlowDirection(PF_TO_ELEMENT); + else + syncMotor->SetPowerFlowDirection(PF_TO_BUS); + + syncMotor->SetElectricalData(childData); - syncMotor->SetElectricalData(childData); + if(reachedMachineLimit) { + syncMotorsOnBus.erase(itsm); + itsm = syncMotorsOnBus.begin(); } } } -- cgit