Validation implemented

1 files changed, 178 insertions, 179 deletions

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<std::vector<std::complex<double> >
         yBus.push_back(line);
     }
 
-    // Build connection map
-    std::vector<std::vector<int> > lineMap;
-    std::vector<std::vector<int> > 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<double>(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<double>(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<double>(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<double>(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<double>(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<double>(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<double>(data.resistance, data.indReactance);
-            yBus[lineMap[lineNumber][1]][lineMap[lineNumber][0]] -=
-                1.0 / std::complex<double>(data.resistance, data.indReactance);
-
-            yBus[lineMap[lineNumber][0]][lineMap[lineNumber][0]] +=
-                1.0 / std::complex<double>(data.resistance, data.indReactance);
-            yBus[lineMap[lineNumber][1]][lineMap[lineNumber][1]] +=
-                1.0 / std::complex<double>(data.resistance, data.indReactance);
-
-            yBus[lineMap[lineNumber][0]][lineMap[lineNumber][0]] +=
-                std::complex<double>(0.0, data.capSusceptance / 2.0);
-            yBus[lineMap[lineNumber][1]][lineMap[lineNumber][1]] +=
-                std::complex<double>(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<double>(data.resistance, data.indReactance);
+            yBus[n2][n1] -= 1.0 / std::complex<double>(data.resistance, data.indReactance);
+
+            yBus[n1][n1] += 1.0 / std::complex<double>(data.resistance, data.indReactance);
+            yBus[n2][n2] += 1.0 / std::complex<double>(data.resistance, data.indReactance);
+
+            yBus[n1][n1] += std::complex<double>(0.0, data.capSusceptance / 2.0);
+            yBus[n2][n2] += std::complex<double>(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<double>(data.resistance, data.indReactance);
-                yBus[transfomerMap[transformerNumber][1]][transfomerMap[transformerNumber][0]] +=
-                    -1.0 / std::complex<double>(data.resistance, data.indReactance);
-
-                yBus[transfomerMap[transformerNumber][0]][transfomerMap[transformerNumber][0]] +=
-                    1.0 / std::complex<double>(data.resistance, data.indReactance);
-                yBus[transfomerMap[transformerNumber][1]][transfomerMap[transformerNumber][1]] +=
-                    1.0 / std::complex<double>(data.resistance, data.indReactance);
+                yBus[n1][n2] += -1.0 / std::complex<double>(data.resistance, data.indReactance);
+                yBus[n2][n1] += -1.0 / std::complex<double>(data.resistance, data.indReactance);
+
+                yBus[n1][n1] += 1.0 / std::complex<double>(data.resistance, data.indReactance);
+                yBus[n2][n2] += 1.0 / std::complex<double>(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<std::vector<std::complex<double> >
                 // Transformer admitance
                 std::complex<double> y = 1.0 / std::complex<double>(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<std::vector<std::complex<double> >
 
 void ElectricCalculation::ValidateElementsPowerFlow(std::vector<std::complex<double> > voltage,
                                                     std::vector<std::complex<double> > power,
+                                                    std::vector<BusType> busType,
                                                     double systemPowerBase)
 {
-    std::vector<std::vector<int> > lineMap;
-    std::vector<std::vector<int> > 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<double> v1 = voltage[lineMap[i][0]];
-            std::complex<double> 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<double> v1 = voltage[n1];
+            std::complex<double> v2 = voltage[n2];
 
             data.current[0] = (v1 - v2) / std::complex<double>(data.resistance, data.indReactance) +
                               v1 * std::complex<double>(0.0, data.capSusceptance / 2.0);
@@ -223,16 +188,24 @@ void ElectricCalculation::ValidateElementsPowerFlow(std::vector<std::complex<dou
             data.powerFlow[0] = v1 * std::conj(data.current[0]);
             data.powerFlow[1] = v2 * std::conj(data.current[1]);
 
-            m_lineList[i]->SetElectricalData(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<double> v1 = voltage[transfomerMap[i][0]];  // Primary voltage
-            std::complex<double> 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<double> v1 = voltage[n1];  // Primary voltage
+            std::complex<double> v2 = voltage[n2];  // Secondary voltage
 
             // Transformer admitance
             std::complex<double> y = 1.0 / std::complex<double>(data.resistance, data.indReactance);
@@ -252,14 +225,19 @@ void ElectricCalculation::ValidateElementsPowerFlow(std::vector<std::complex<dou
             data.powerFlow[0] = v1 * std::conj(data.current[0]);
             data.powerFlow[1] = v2 * std::conj(data.current[1]);
 
-            m_transformerList[i]->SetElectricalData(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<SyncGenerator*> syncGeneratorsOnBus;
@@ -267,95 +245,116 @@ void ElectricCalculation::ValidateElementsPowerFlow(std::vector<std::complex<dou
         std::complex<double> 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<double>(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<double>(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<double>(childData.activePower, childData.reactivePower);
-                else if(childData.loadType == CONST_IMPEDANCE)
-                    loadPower += std::pow(std::abs(voltage[i]), 2) *
-                                 std::complex<double>(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<double>(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<double>(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<double>(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
     }
 }