ElectricCalculation.h

Go to the documentation of this file.

/*
 *  Copyright (C) 2017  Thales Lima Oliveira <thales@ufu.br>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#ifndef ELECTRICCALCULATION_H
#define ELECTRICCALCULATION_H
 
#include <complex>
#include <vector>
 
#include "../elements/Element.h"
#include "../elements/powerElement/Bus.h"
#include "../elements/powerElement/Capacitor.h"
#include "../elements/powerElement/HarmCurrent.h"
#include "../elements/powerElement/IndMotor.h"
#include "../elements/powerElement/Inductor.h"
#include "../elements/powerElement/Line.h"
#include "../elements/powerElement/Load.h"
#include "../elements/powerElement/PowerElement.h"
#include "../elements/powerElement/SyncGenerator.h"
#include "../elements/powerElement/SyncMotor.h"
#include "../elements/powerElement/Transformer.h"
#include "../elements/powerElement/EMTElement.h"
 
#include "../utils/PropertiesData.h"
 
enum BusType {
    BUS_SLACK = 0, 
    BUS_PV,        
    BUS_PQ         
};
 
enum ReactiveLimitsType {
    RL_UNLIMITED = 0,     
    RL_LIMITED,           
    RL_UNLIMITED_SOURCE,  
    RL_MAX_REACHED,       
    RL_MIN_REACHED,       
    RL_NONE_REACHED       
};
 
enum YBusSequence {
    POSITIVE_SEQ = 0, 
    NEGATIVE_SEQ,     
    ZERO_SEQ          
};
 
struct ReactiveLimits {
    double maxLimit = 0.0; 
    double minLimit = 0.0; 
    ReactiveLimitsType maxLimitType = RL_UNLIMITED; 
    ReactiveLimitsType minLimitType = RL_UNLIMITED; 
    ReactiveLimitsType limitReached = RL_NONE_REACHED; 
};
 
struct ReactiveMachine {
    double qMax; 
    double qMin; 
    bool hasMax; 
    bool hasMin; 
    bool fixed = false; 
    double q = 0.0; 
    Machines* machine; 
    bool isGenerator;  
};
 
class ElectricCalculation
{
public:
    ElectricCalculation();
 
    ~ElectricCalculation();
 
    virtual void GetElementsFromList(std::vector<Element*> elementList);
 
    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);
 
    virtual bool InvertMatrix(std::vector<std::vector<std::complex<double> > > matrix,
        std::vector<std::vector<std::complex<double> > >& inverse);
 
    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);
 
    void ABCtoDQ0(std::complex<double> complexValue, double angle, double& dValue, double& qValue);
 
    void DQ0toABC(double dValue, double qValue, double angle, std::complex<double>& complexValue);
 
    std::vector<std::complex<double> > GaussianElimination(std::vector<std::vector<std::complex<double> > > matrix,
        std::vector<std::complex<double> > array);
 
    std::vector<double> GaussianElimination(std::vector<std::vector<double> > matrix, std::vector<double> array);
 
    Machines::SyncMachineModel GetMachineModel(SyncGenerator* generator);
 
    std::vector<std::complex<double> > ComplexMatrixTimesVector(std::vector<std::vector<std::complex<double> > > matrix,
        std::vector<std::complex<double> > 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);
 
    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);
 
    bool GetParentBus(Element* childElement, Bus*& parentBus);
 
    bool GetParentBus(Element* childElement, Bus*& parentBus1, Bus*& parentBus2);
 
    bool CalculateEMTElementsAdmittance(const double& basePower, wxString& errorMsg);
 
    bool CalculateEMTElementsPower(const double& basePower, wxString& errorMsg, bool updateCurrent = true);
 
    double CalculateEMTPowerError(const std::vector< std::complex<double> >& voltage, std::vector< std::complex<double> >& power, const double& basePower, wxString& errorMsg);
 
    const std::vector<PowerElement*> GetPowerElementList() const { return m_powerElementList; }
    const std::vector<Bus*> GetBusList() const { return m_busList; }
    const std::vector<Capacitor*> GetCapacitorList() const { return m_capacitorList; }
    const std::vector<IndMotor*> GetIndMotorList() const { return m_indMotorList; }
    const std::vector<Inductor*> GetInductorList() const { return m_inductorList; }
    const std::vector<Line*> GetLineList() const { return m_lineList; }
    const std::vector<Load*> GetLoadList() const { return m_loadList; }
    const std::vector<SyncGenerator*> GetSyncGeneratorList() const { return m_syncGeneratorList; }
    const std::vector<SyncMotor*> GetSyncMotorList() const { return m_syncMotorList; }
    const std::vector<Transformer*> GetTransformerList() const { return m_transformerList; }
    const std::vector<HarmCurrent*> GetHarmCurrentList() const { return m_harmCurrentList; }
    const std::vector<EMTElement*> GetEMTElementList() const { return m_emtElementList; }
 
protected:
    void GetNextConnection(const unsigned int& checkBusNumber, const std::vector< std::vector< std::complex<double> > >& yBus, std::vector<bool>& connToSlack);
 
    void DistributeReactivePower(std::vector<ReactiveMachine>& machines, double qTotal);
 
    std::vector<PowerElement*> m_powerElementList;
    std::vector<Bus*> m_busList;
    std::vector<Capacitor*> m_capacitorList;
    std::vector<IndMotor*> m_indMotorList;
    std::vector<Inductor*> m_inductorList;
    std::vector<Line*> m_lineList;
    std::vector<Load*> m_loadList;
    std::vector<SyncGenerator*> m_syncGeneratorList;
    std::vector<SyncMotor*> m_syncMotorList;
    std::vector<Transformer*> m_transformerList;
    std::vector<HarmCurrent*> m_harmCurrentList;
    std::vector<EMTElement*> m_emtElementList;
};
 
#endif  // ELECTRICCALCULATION_H