PowerQuality Class Reference

Responsible for the power quality calculations. More...

#include <PowerQuality.h>

Inheritance diagram for PowerQuality:

Collaboration diagram for PowerQuality:

Classes
struct	HarmonicYbus

Public Member Functions
	PowerQuality (std::vector< Element * > elementList)
virtual wxString	GetErrorMessage ()
virtual void	CalculateHarmonicYbusList (double systemPowerBase=100e6, HarmLoadConnection loadConnection=HarmLoadConnection::PARALLEL)
virtual void	CalculateHarmonicYbus (std::vector< std::vector< std::complex< double > > > &yBus, double systemPowerBase, double order, bool ignoreTransformerConnection=false, HarmLoadConnection loadConnection=HarmLoadConnection::PARALLEL)
virtual bool	CalculateDistortions (double systemPowerBase=100e6, HarmLoadConnection loadConnection=HarmLoadConnection::PARALLEL)
virtual bool	CalculateFrequencyResponse (double systemFreq=60.0, double initFreq=0.0, double endFreq=1500.0, double stepFreq=1.0, int injBusNumber=0, double systemPowerBase=100e6, HarmLoadConnection loadConnection=HarmLoadConnection::PARALLEL)
virtual std::vector< double >	GetHarmonicOrdersList ()
virtual std::vector< double >	GetFrequencies ()
Public Member Functions inherited from ElectricCalculation
	ElectricCalculation ()
	Constructor.
	~ElectricCalculation ()
	Destructor.
virtual void	GetElementsFromList (std::vector< Element * > elementList)
	Separate the power elements from a generic list.
virtual bool	GetYBus (std::vector< std::vector< std::complex< double > > > &yBus, double systemPowerBase, YBusSequence sequence=POSITIVE_SEQ, bool includeSyncMachines=false, bool allLoadsAsImpedances=false, bool usePowerFlowVoltagesOnImpedances=false)
	Get the admittance matrix from the list of elements (use GetElementsFromList first).
virtual bool	InvertMatrix (std::vector< std::vector< std::complex< double > > > matrix, std::vector< std::vector< std::complex< double > > > &inverse)
	Invert a matrix.
virtual void	UpdateElementsPowerFlow (std::vector< std::complex< double > > voltage, std::vector< std::complex< double > > power, std::vector< BusType > busType, std::vector< ReactiveLimits > reactiveLimit, double systemPowerBase)
	Update the elements after the power flow calculation.
void	ABCtoDQ0 (std::complex< double > complexValue, double angle, double &dValue, double &qValue)
	Convert a complex phasor in ABC representation to DQ components.
void	DQ0toABC (double dValue, double qValue, double angle, std::complex< double > &complexValue)
	Convert DQ components to a complex phasor in ABC representation.
std::vector< std::complex< double > >	GaussianElimination (std::vector< std::vector< std::complex< double > > > matrix, std::vector< std::complex< double > > array)
	Solve a linear system using Gaussian elimination (complex version).
std::vector< double >	GaussianElimination (std::vector< std::vector< double > > matrix, std::vector< double > array)
	Solve a linear system using Gaussian elimination (real version).
Machines::SyncMachineModel	GetMachineModel (SyncGenerator *generator)
	Get the synchronous machine model used by the generator based on user-defined parameters.
std::vector< std::complex< double > >	ComplexMatrixTimesVector (std::vector< std::vector< std::complex< double > > > matrix, std::vector< std::complex< double > > vector)
	Multiply a complex matrix by a complex vector.
void	GetLUDecomposition (std::vector< std::vector< std::complex< double > > > matrix, std::vector< std::vector< std::complex< double > > > &matrixL, std::vector< std::vector< std::complex< double > > > &matrixU)
	Compute the LU decomposition of a matrix.
std::vector< std::complex< double > >	LUEvaluate (std::vector< std::vector< std::complex< double > > > u, std::vector< std::vector< std::complex< double > > > l, std::vector< std::complex< double > > b)
	Solve a linear system using LU decomposition.
bool	GetParentBus (Element *childElement, Bus *&parentBus)
	Get the parent bus of a given shunt element.
bool	GetParentBus (Element *childElement, Bus *&parentBus1, Bus *&parentBus2)
	Get the parent buses of a two-terminal element (branch).
bool	CalculateEMTElementsAdmittance (const double &basePower, wxString &errorMsg)
	Calculate the admittance of EMT elements.
bool	CalculateEMTElementsPower (const double &basePower, wxString &errorMsg, bool updateCurrent=true)
	Calculate the power of EMT elements.
double	CalculateEMTPowerError (const std::vector< std::complex< double > > &voltage, std::vector< std::complex< double > > &power, const double &basePower, wxString &errorMsg)
	Calculate the power mismatch error for EMT simulation.
const std::vector< PowerElement * >	GetPowerElementList () const
	Get the power elements of the system (use GetElementsFromList first).
const std::vector< Bus * >	GetBusList () const
	Get the buses of the system (use GetElementsFromList first).
const std::vector< Capacitor * >	GetCapacitorList () const
	Get the capacitors of the system (use GetElementsFromList first).
const std::vector< IndMotor * >	GetIndMotorList () const
	Get the induction motors of the system (use GetElementsFromList first).
const std::vector< Inductor * >	GetInductorList () const
	Get the inductors of the system (use GetElementsFromList first).
const std::vector< Line * >	GetLineList () const
	Get the lines of the system (use GetElementsFromList first).
const std::vector< Load * >	GetLoadList () const
	Get the loads of the system (use GetElementsFromList first).
const std::vector< SyncGenerator * >	GetSyncGeneratorList () const
	Get the synchronous generators of the system (use GetElementsFromList first).
const std::vector< SyncMotor * >	GetSyncMotorList () const
	Get the synchronous motors of the system (use GetElementsFromList first).
const std::vector< Transformer * >	GetTransformerList () const
	Get the transformers of the system (use GetElementsFromList first).
const std::vector< HarmCurrent * >	GetHarmCurrentList () const
	Get the harmonic current source of the system (use GetElementsFromList first).
const std::vector< EMTElement * >	GetEMTElementList () const
	Get the electromagnetic element list of the system (use GetElementsFromList first).

Protected Member Functions
std::vector< std::vector< std::complex< double > > >	GetTransformerHarmAdmmitance (Transformer *transformer, double systemPowerBase, double hOrder, bool ignoreConnection=false)
Protected Member Functions inherited from ElectricCalculation
void	GetNextConnection (const unsigned int &checkBusNumber, const std::vector< std::vector< std::complex< double > > > &yBus, std::vector< bool > &connToSlack)
	Recursively check if a bus is electrically connected to the slack bus.
void	DistributeReactivePower (std::vector< ReactiveMachine > &machines, double qTotal)
	Distribute reactive power among synchronous machines connected to the same bus.

Protected Attributes
std::vector< HarmonicYbus >	m_harmYbusList
std::vector< double >	m_frequencyList
wxString	m_errorMsg = ""
Protected Attributes inherited from ElectricCalculation
std::vector< PowerElement * >	m_powerElementList
	List of power elements in the system.
std::vector< Bus * >	m_busList
	List of buses in the system.
std::vector< Capacitor * >	m_capacitorList
	List of capacitor elements in the system.
std::vector< IndMotor * >	m_indMotorList
	List of induction motors in the system.
std::vector< Inductor * >	m_inductorList
	List of inductors in the system.
std::vector< Line * >	m_lineList
	List of transmission lines in the system.
std::vector< Load * >	m_loadList
	List of load elements in the system.
std::vector< SyncGenerator * >	m_syncGeneratorList
	List of synchronous generators in the system.
std::vector< SyncMotor * >	m_syncMotorList
	List of synchronous motors in the system.
std::vector< Transformer * >	m_transformerList
	List of transformers in the system.
std::vector< HarmCurrent * >	m_harmCurrentList
	List of harmonic current sources in the system.
std::vector< EMTElement * >	m_emtElementList
	List of electromagnetic transient (EMT) elements in the system.

Detailed Description

Responsible for the power quality calculations.

Author

Thales Lima Oliveira thale.nosp@m.s@uf.nosp@m.u.br

Date

24/04/2019

Definition at line 16 of file PowerQuality.h.

Constructor & Destructor Documentation

PowerQuality() [1/2]

PowerQuality::PowerQuality

(

)

Definition at line 3 of file PowerQuality.cpp.

{}

PowerQuality() [2/2]

PowerQuality::PowerQuality

(

std::vector< Element * >

elementList

)

Definition at line 7 of file PowerQuality.cpp.

{ GetElementsFromList(elementList); }

~PowerQuality()

PowerQuality::~PowerQuality

(

)

Definition at line 5 of file PowerQuality.cpp.

{}

Member Function Documentation

CalculateDistortions()

bool PowerQuality::CalculateDistortions ( double  systemPowerBase = 100e6, HarmLoadConnection  loadConnection = HarmLoadConnection::PARALLEL  )

virtual

Definition at line 160 of file PowerQuality.cpp.

{
    // Get harmonic orders
    m_harmYbusList.clear();
    std::vector<double> harmOrders = GetHarmonicOrdersList();
 
    // Fill the Ybuses
    for (unsigned int i = 0; i < harmOrders.size(); ++i) {
        HarmonicYbus newYbus;
        newYbus.order = harmOrders[i];
        m_harmYbusList.push_back(newYbus);
    }
    CalculateHarmonicYbusList(systemPowerBase, loadConnection);
 
    // Initialize current arrays with zeros
    std::vector<std::vector<std::complex<double> > > iHarmInjList;
    for (unsigned int i = 0; i < harmOrders.size(); i++) {
        std::vector<std::complex<double> > line;
        for (unsigned int j = 0; j < m_busList.size(); j++) { line.push_back(std::complex<double>(0.0, 0.0)); }
        iHarmInjList.push_back(line);
    }
 
    // Fill the current array
    for (unsigned int i = 0; i < harmOrders.size(); ++i) {
        for (auto it = m_harmCurrentList.begin(), itEnd = m_harmCurrentList.end(); it != itEnd; ++it) {
            HarmCurrent* harmCurrent = *it;
            if (harmCurrent->IsOnline()) {
                // Get only the current order in analysis
                for (unsigned int k = 0; k < harmCurrent->GetElectricalData().harmonicOrder.size(); ++k) {
                    if (harmCurrent->GetElectricalData().harmonicOrder[k] == static_cast<int>(harmOrders[i])) {
                        Bus* parentBus = static_cast<Bus*>(harmCurrent->GetParentList()[0]);
                        auto busData = parentBus->GetElectricalData();
                        int j = busData.number;
 
                        // Bus voltage
                        double voltage = busData.nominalVoltage;
                        if (busData.nominalVoltageUnit == ElectricalUnit::UNIT_kV) voltage *= 1e3;
 
                        auto puData = harmCurrent->GetPUElectricalData(systemPowerBase, voltage);
 
                        iHarmInjList[i][j] += std::complex<double>(
                            puData.injHarmCurrent[k] * std::cos(wxDegToRad(puData.injHarmAngle[k])),
                            puData.injHarmCurrent[k] * std::sin(wxDegToRad(puData.injHarmAngle[k])));
                    }
                }
            }
        }
        // EMT elements
        for (auto* emtElement : m_emtElementList) {
            if (!emtElement->IsOnline()) continue; // Skip offline elements
            if (emtElement->GetParentList().size() > 0) {
                if (emtElement->GetParentList()[0] != nullptr) {
                    auto data = emtElement->GetEMTElementData();
                    for (auto const& [order, current] : data.currHarmonics) {
                        if (order == 1) continue; // Skip fundamental
                        else if (order == static_cast<int>(harmOrders[i])) {
                            Bus* parentBus = static_cast<Bus*>(emtElement->GetParentList()[0]);
                            auto busData = parentBus->GetElectricalData();
                            int j = busData.number;
 
                            double voltage = busData.nominalVoltage;
                            if (busData.nominalVoltageUnit == ElectricalUnit::UNIT_kV) voltage *= 1e3;
                            double baseCurrent = systemPowerBase / (std::sqrt(3.0) * voltage);
 
                            iHarmInjList[i][j] += current / baseCurrent;
                        }
                    }
                }
            }
        }
    }
 
    // Calculate harmonic voltages
    std::vector<std::vector<std::complex<double> > > vHarmList;
    for (unsigned int i = 0; i < m_harmYbusList.size(); ++i) {
        vHarmList.push_back(GaussianElimination(m_harmYbusList[i].yBus, iHarmInjList[i]));
    }
 
    for (auto it = m_busList.begin(), itEnd = m_busList.end(); it != itEnd; ++it) {
        Bus* bus = *it;
        auto data = bus->GetElectricalData();
        data.harmonicOrder.clear();
        data.harmonicVoltage.clear();
        double thd = 0.0;
        for (unsigned int i = 0; i < vHarmList.size(); ++i) {
            thd += std::abs(vHarmList[i][data.number]) * std::abs(vHarmList[i][data.number]);
            data.harmonicVoltage.push_back(vHarmList[i][data.number]);
            data.harmonicOrder.push_back(static_cast<int>(harmOrders[i]));
        }
        // distortion = std::sqrt(distortion) / std::abs(data.voltage);
        thd = std::sqrt(thd) * 100.0;
        data.thd = thd;
        bus->SetElectricalData(data);
    }
 
    // Calculate harmonic currents through branches:
    // Lines
    for (auto* line : m_lineList) {
        if (line->IsOnline()) {
            LineElectricalData data = line->GetPUElectricalData(systemPowerBase);
 
            auto busData1 = static_cast<Bus*>(line->GetParentList()[0])->GetElectricalData();
            auto busData2 = static_cast<Bus*>(line->GetParentList()[1])->GetElectricalData();
 
            if (busData1.harmonicVoltage.size() != busData1.harmonicVoltage.size()) {
                m_errorMsg = _("Error calculating the harmonic current in \"") + data.name + wxT("\".");
                return false;
            }
 
            // Clear old currents
            data.harmonicOrder.clear();
            data.harmonicCurrent[0].clear();
            data.harmonicCurrent[1].clear();
 
            int i = 0;
            for (auto& hVoltage : busData1.harmonicVoltage) {
                int order = busData1.harmonicOrder[i];
                data.harmonicOrder.push_back(order);
 
                std::complex<double> v1 = hVoltage;
                std::complex<double> v2 = busData2.harmonicVoltage[i];
                std::complex<double> zs = std::complex<double>(data.resistance, data.indReactance * order);
                std::complex<double> bsh = std::complex<double>(0.0, (data.capSusceptance * order) / 2.0);
 
                data.harmonicCurrent[0].push_back((v1 - v2) / zs + v1 * bsh);
                data.harmonicCurrent[1].push_back((v2 - v1) / zs + v2 * bsh);
                i++;
            }
 
            line->SetElectricalData(data);
        }
    }
    // Transformers
    for (auto* transformer : m_transformerList) {
        if (transformer->IsOnline()) {
            TransformerElectricalData data = transformer->GetPUElectricalData(systemPowerBase);
 
            auto busData1 = static_cast<Bus*>(transformer->GetParentList()[0])->GetElectricalData();
            auto busData2 = static_cast<Bus*>(transformer->GetParentList()[1])->GetElectricalData();
 
            if (busData1.harmonicVoltage.size() != busData1.harmonicVoltage.size()) {
                m_errorMsg = _("Error calculating the harmonic current in \"") + data.name + wxT("\".");
                return false;
            }
 
            // Clear old currents
            data.harmonicOrder.clear();
            data.harmonicCurrent[0].clear();
            data.harmonicCurrent[1].clear();
 
            int i = 0;
            for (auto& hVoltage : busData1.harmonicVoltage) {
                int order = busData1.harmonicOrder[i];
                data.harmonicOrder.push_back(order);
 
                std::complex<double> v1 = hVoltage;
                std::complex<double> v2 = busData2.harmonicVoltage[i];
 
                auto yMatrix = GetTransformerHarmAdmmitance(transformer, systemPowerBase, order);
 
                data.harmonicCurrent[0].push_back(yMatrix[0][0] * v1 + yMatrix[0][1] * v2);
                data.harmonicCurrent[1].push_back(yMatrix[1][0] * v1 + yMatrix[1][1] * v2);
 
                i++;
            }
 
            transformer->SetElectricaData(data);
 
        }
    }
 
    return true;
}

CalculateFrequencyResponse()

bool PowerQuality::CalculateFrequencyResponse ( double  systemFreq = 60.0, double  initFreq = 0.0, double  endFreq = 1500.0, double  stepFreq = 1.0, int  injBusNumber = 0, double  systemPowerBase = 100e6, HarmLoadConnection  loadConnection = HarmLoadConnection::PARALLEL  )

virtual

Definition at line 449 of file PowerQuality.cpp.

{
    // Clear all previous data
    for (unsigned int i = 0; i < m_busList.size(); i++) {
        auto data = m_busList[i]->GetElectricalData();
        data.absImpedanceVector.clear();
        data.absImpedanceVector.shrink_to_fit();
        m_busList[i]->SetElectricalData(data);
    }
 
    // Create and fill with zeros the YBus
    std::vector<std::vector<std::complex<double> > > yBus;
    for (unsigned int i = 0; i < m_busList.size(); i++) {
        std::vector<std::complex<double> > line;
        for (unsigned int j = 0; j < m_busList.size(); j++) { line.push_back(std::complex<double>(0.0, 0.0)); }
        yBus.push_back(line);
    }
    // Create and fill with zeros the injected current vector
    std::vector<std::complex<double> > iInj;
    for (unsigned int i = 0; i < m_busList.size(); i++) { iInj.push_back(std::complex<double>(0.0, 0.0)); }
    iInj[injBusNumber] = std::complex<double>(1.0, 0.0);
 
    if (initFreq < 1e-6) initFreq = stepFreq;
    double currentFreq = initFreq;
    while (currentFreq <= endFreq) {
        m_frequencyList.push_back(currentFreq);
 
        double order = currentFreq / systemFreq;
 
        // Fill YBus with zeros
        for (unsigned int i = 0; i < m_busList.size(); i++) {
            for (unsigned int j = 0; j < m_busList.size(); j++) { yBus[i][j] = std::complex<double>(0.0, 0.0); }
        }
 
        CalculateHarmonicYbus(yBus, systemPowerBase, order, true, loadConnection);
 
        for (unsigned int i = 0; i < m_busList.size(); i++) {
            auto data = m_busList[i]->GetElectricalData();
            if (data.plotPQData) {
                auto zh = GaussianElimination(yBus, iInj);
 
                data.absImpedanceVector.push_back(std::abs(zh[data.number]));
                m_busList[i]->SetElectricalData(data);
            }
        }
 
        currentFreq += stepFreq;
    }
    return false;
}

CalculateHarmonicYbus()

void PowerQuality::CalculateHarmonicYbus ( std::vector< std::vector< std::complex< double > > > &  yBus, double  systemPowerBase, double  order, bool  ignoreTransformerConnection = false, HarmLoadConnection  loadConnection = HarmLoadConnection::PARALLEL  )

virtual

Definition at line 31 of file PowerQuality.cpp.

{
    // Load
    for (auto it = m_loadList.begin(), itEnd = m_loadList.end(); it != itEnd; ++it) {
        Load* load = *it;
        if (load->IsOnline() && loadConnection != HarmLoadConnection::DISCONNECTED) {
            auto busData = static_cast<Bus*>(load->GetParentList()[0])->GetElectricalData();
            if (busData.isConnected) {
                int n = busData.number;
                LoadElectricalData data = load->GetPUElectricalData(systemPowerBase);
 
                std::complex<double> v = static_cast<Bus*>(load->GetParentList()[0])->GetElectricalData().voltage;
 
                //tex:
                // $$\bar{Z}=\frac{V^2}{P-jQ}=R+jX_L \rightarrow \bar{Z}_h=R+jX_L \cdot h$$
                std::complex<double> zLoad = (std::abs(v) * std::abs(v)) / std::complex<double>(data.activePower, -data.reactivePower);
                zLoad = std::complex<double>(zLoad.real(), zLoad.imag() * order);
                if (std::abs(zLoad.real()) < 1e-6) zLoad = std::complex<double>(1e-6, zLoad.imag());
                if (std::abs(zLoad.imag()) < 1e-6) zLoad = std::complex<double>(zLoad.real(), 1e-6);
                std::complex<double> yLoad = 0.0;
 
                //tex:
                //Parallel:
                //$$\bar{Y}=\frac{1}{R}+\frac{1}{jX_L}$$
                //Series:
                //$$\bar{Y}=\frac{1}{R+jX_L}$$
                if (loadConnection == HarmLoadConnection::PARALLEL)
                    yLoad = std::complex<double>(1.0, 0.0) / std::complex<double>(zLoad.real(), 0.0) + std::complex<double>(1.0, 0.0) / std::complex<double>(0.0, zLoad.imag());
                else if (loadConnection == HarmLoadConnection::SERIES)
                    yLoad = std::complex<double>(1.0, 0.0) / zLoad;
 
                /*std::complex<double> yLoad = std::complex<double>(data.activePower, -data.reactivePower / order);
                std::complex<double> v = static_cast<Bus*>(load->GetParentList()[0])->GetElectricalData().voltage;
                yLoad /= (std::abs(v) * std::abs(v));*/
 
                yBus[n][n] += yLoad;
            }
        }
    }
 
    // Capacitor
    for (auto it = m_capacitorList.begin(), itEnd = m_capacitorList.end(); it != itEnd; ++it) {
        Capacitor* capacitor = *it;
        if (capacitor->IsOnline()) {
            auto busData = static_cast<Bus*>(capacitor->GetParentList()[0])->GetElectricalData();
            if (busData.isConnected) {
                int n = busData.number;
                CapacitorElectricalData data = capacitor->GetPUElectricalData(systemPowerBase);
                yBus[n][n] += std::complex<double>(0.0, data.reactivePower) * order;
            }
        }
    }
 
    // Inductor
    for (auto it = m_inductorList.begin(), itEnd = m_inductorList.end(); it != itEnd; ++it) {
        Inductor* inductor = *it;
        if (inductor->IsOnline()) {
            auto busData = static_cast<Bus*>(inductor->GetParentList()[0])->GetElectricalData();
            if (busData.isConnected) {
                int n = busData.number;
                InductorElectricalData data = inductor->GetPUElectricalData(systemPowerBase);
                yBus[n][n] += std::complex<double>(0.0, -data.reactivePower) / order;
            }
        }
    }
 
    // Power line
    for (auto it = m_lineList.begin(), itEnd = m_lineList.end(); it != itEnd; ++it) {
        Line* line = *it;
        if (line->IsOnline()) {
            LineElectricalData data = line->GetPUElectricalData(systemPowerBase);
 
            int n1 = static_cast<Bus*>(line->GetParentList()[0])->GetElectricalData().number;
            int n2 = static_cast<Bus*>(line->GetParentList()[1])->GetElectricalData().number;
 
            yBus[n1][n2] -= 1.0 / std::complex<double>(data.resistance, data.indReactance * order);
            yBus[n2][n1] -= 1.0 / std::complex<double>(data.resistance, data.indReactance * order);
 
            yBus[n1][n1] += 1.0 / std::complex<double>(data.resistance, data.indReactance * order);
            yBus[n2][n2] += 1.0 / std::complex<double>(data.resistance, data.indReactance * order);
 
            yBus[n1][n1] += std::complex<double>(0.0, (data.capSusceptance * order) / 2.0);
            yBus[n2][n2] += std::complex<double>(0.0, (data.capSusceptance * order) / 2.0);
        }
    }
 
    // Transformer
    for (auto it = m_transformerList.begin(), itEnd = m_transformerList.end(); it != itEnd; ++it) {
        Transformer* transformer = *it;
 
        if (transformer->IsOnline()) {
            TransformerElectricalData data = transformer->GetPUElectricalData(systemPowerBase);
 
            int n1 = static_cast<Bus*>(transformer->GetParentList()[0])->GetElectricalData().number;
            int n2 = static_cast<Bus*>(transformer->GetParentList()[1])->GetElectricalData().number;
 
            auto yMatrix = GetTransformerHarmAdmmitance(transformer, systemPowerBase, order, ignoreTransformerConnection);
 
            yBus[n1][n2] += yMatrix[0][1];
            yBus[n2][n1] += yMatrix[1][0];
            yBus[n1][n1] += yMatrix[0][0];
            yBus[n2][n2] += yMatrix[1][1];
        }
    }
 
    // Synchronous generator
    for (auto it = m_syncGeneratorList.begin(), itEnd = m_syncGeneratorList.end(); it != itEnd; ++it) {
        SyncGenerator* syncGenerator = *it;
        if (syncGenerator->IsOnline()) {
            int n = static_cast<Bus*>(syncGenerator->GetParentList()[0])->GetElectricalData().number;
            SyncGeneratorElectricalData data = syncGenerator->GetPUElectricalData(systemPowerBase);
            yBus[n][n] += 1.0 / std::complex<double>(data.positiveResistance, data.positiveReactance * order);
        }
    }
    // Synchronous motor
    for (auto it = m_syncMotorList.begin(), itEnd = m_syncMotorList.end(); it != itEnd; ++it) {
        SyncMotor* syncMotor = *it;
        if (syncMotor->IsOnline()) {
            int n = static_cast<Bus*>(syncMotor->GetParentList()[0])->GetElectricalData().number;
            SyncMotorElectricalData data = syncMotor->GetPUElectricalData(systemPowerBase);
            yBus[n][n] += 1.0 / std::complex<double>(data.positiveResistance, data.positiveReactance * order);
        }
    }
}

CalculateHarmonicYbusList()

void PowerQuality::CalculateHarmonicYbusList ( double  systemPowerBase = 100e6, HarmLoadConnection  loadConnection = HarmLoadConnection::PARALLEL  )

virtual

Definition at line 9 of file PowerQuality.cpp.

{
    // Clear and fill with zeros all the harmonic Ybuses
    for (auto it = m_harmYbusList.begin(), itEnd = m_harmYbusList.end(); it != itEnd; ++it) {
        HarmonicYbus harmYBus = *it;
        harmYBus.yBus.clear();
        for (unsigned int i = 0; i < m_busList.size(); i++) {
            std::vector<std::complex<double> > line;
            for (unsigned int j = 0; j < m_busList.size(); j++) { line.push_back(std::complex<double>(0.0, 0.0)); }
            harmYBus.yBus.push_back(line);
        }
        *it = harmYBus;
    }
 
    // Fill all Ybuses
    for (auto itYbus = m_harmYbusList.begin(), itYbusEnd = m_harmYbusList.end(); itYbus != itYbusEnd; ++itYbus) {
        HarmonicYbus harmYBus = *itYbus;
        CalculateHarmonicYbus(harmYBus.yBus, systemPowerBase, harmYBus.order, false, loadConnection);
        *itYbus = harmYBus;
    }
}

GetErrorMessage()

virtual wxString PowerQuality::GetErrorMessage ( )

inlinevirtual

Definition at line 28 of file PowerQuality.h.

{ return m_errorMsg; }

GetFrequencies()

virtual std::vector< double > PowerQuality::GetFrequencies ( )

inlinevirtual

Definition at line 46 of file PowerQuality.h.

{ return m_frequencyList; }

GetHarmonicOrdersList()

std::vector< double > PowerQuality::GetHarmonicOrdersList ( )

virtual

Definition at line 334 of file PowerQuality.cpp.

{
    std::vector<int> harmOrders;
    auto harmCurrentList = GetHarmCurrentList();
    // Check all harmonic sources and get all harmonic orders in the system
    for (auto it = harmCurrentList.begin(), itEnd = harmCurrentList.end(); it != itEnd; ++it) {
        HarmCurrent* harmCurrent = *it;
        if (harmCurrent->IsOnline()) {
            auto data = harmCurrent->GetElectricalData();
            for (unsigned int i = 0; i < data.harmonicOrder.size(); ++i) {
                int order = data.harmonicOrder[i];
                // Check if this harmonic order have been added already
                bool newOrder = true;
                for (unsigned int j = 0; j < harmOrders.size(); ++j) {
                    if (order == harmOrders[j]) {
                        newOrder = false;
                        break;
                    }
                }
                if (newOrder) harmOrders.push_back(order);
            }
        }
    }
    // Check all harmonic from EMT elements
    for (auto* emtElement : m_emtElementList) {
        if (!emtElement->IsOnline()) continue; // Skip offline elements
 
        auto data = emtElement->GetEMTElementData();
        for (auto const& [order, current] : data.currHarmonics) {
            if (order == 1) continue; // Skip fundamental
            bool newOrder = true;
            for (int vecOrder : harmOrders) {
                if (order == vecOrder) {
                    newOrder = false;
                    break;
                }
            }
            if (newOrder) harmOrders.push_back(order);
        }
    }
 
    std::vector<double> doubleHarmOrder;
    for (unsigned int i = 0; i < harmOrders.size(); ++i) {
        doubleHarmOrder.push_back(static_cast<double>(harmOrders[i]));
    }
    return doubleHarmOrder;
}

GetTransformerHarmAdmmitance()

std::vector< std::vector< std::complex< double > > > PowerQuality::GetTransformerHarmAdmmitance ( Transformer *  transformer, double  systemPowerBase, double  hOrder, bool  ignoreConnection = false  )

protected

Definition at line 382 of file PowerQuality.cpp.

{
    TransformerElectricalData data = transformer->GetPUElectricalData(systemPowerBase);
 
    std::complex<double> ys = std::complex<double>(1.0, 0.0) / std::complex<double>(data.resistance, data.indReactance * hOrder);
    std::complex<double> zeroCpx(0.0, 0.0);
    std::vector<std::vector< std::complex<double> > > yMatrix{ {zeroCpx, zeroCpx}, {zeroCpx, zeroCpx} };
 
    // 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) || ignoreConnection) {
        yMatrix[0][0] = ys;
        yMatrix[1][1] = ys;
        yMatrix[0][1] = -ys;
        yMatrix[1][0] = -ys;
    }
    else {
        // 1. If the harmonic order is negative sequence (order % 3 == 2), change the phase shift signal;
        // 2. If the harmonic order if zero sequence (order % 3 == 0). transformer connection must be considered.
        double radPhaseShift = wxDegToRad(data.phaseShift);
 
        if (static_cast<int>(hOrder) % 3 != 0) { // Positive and Negative sequences
            if (static_cast<int>(hOrder) % 3 == 2) { // Negative sequence
                radPhaseShift *= -1.0;
            }
            std::complex<double> a = std::complex<double>(data.turnsRatio * std::cos(radPhaseShift),
                -data.turnsRatio * std::sin(radPhaseShift));
 
            yMatrix[0][0] = ys / (std::pow(std::abs(a), 2.0));
            yMatrix[0][1] = -(ys / std::conj(a));
            yMatrix[1][0] = -(ys / a);
            yMatrix[1][1] = ys;
        }
        else { // Zero sequence
            switch (data.connection) {
            case GWYE_GWYE: {
                ys = 1.0 / std::complex<double>(
                    data.zeroResistance + 3.0 * (data.primaryGrndResistance + data.secondaryGrndResistance),
                    data.zeroIndReactance +
                    3.0 * (data.primaryGrndReactance + data.secondaryGrndReactance));
                std::complex<double> a = std::complex<double>(data.turnsRatio, 0.0);
 
                yMatrix[0][0] = ys / (a * a);
                yMatrix[0][1] = -(ys / a);
                yMatrix[1][0] = -(ys / a);
                yMatrix[1][1] = ys;
            } break;
            case DELTA_GWYE: {
                ys = 1.0 / std::complex<double>(data.zeroResistance + 3.0 * (data.secondaryGrndResistance),
                    data.zeroIndReactance + 3.0 * (data.secondaryGrndReactance));
                yMatrix[1][1] = ys;
                break;
            }
            case GWYE_DELTA: {
                ys = 1.0 / std::complex<double>(data.zeroResistance + 3.0 * (data.primaryGrndResistance),
                    data.zeroIndReactance + 3.0 * (data.primaryGrndReactance));
                yMatrix[0][0] = ys;
                break;
            }
            default:
                break;
            }
        }
    }
 
    return yMatrix;
}

Member Data Documentation

m_errorMsg

wxString PowerQuality::m_errorMsg = ""

protected

Definition at line 53 of file PowerQuality.h.

m_frequencyList

std::vector<double> PowerQuality::m_frequencyList

protected

Definition at line 52 of file PowerQuality.h.

m_harmYbusList

std::vector<HarmonicYbus> PowerQuality::m_harmYbusList

protected

Definition at line 51 of file PowerQuality.h.

---

The documentation for this class was generated from the following files:

• Project/simulation/PowerQuality.h
• Project/simulation/PowerQuality.cpp