PowerElement.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 POWERELEMENT_H
#define POWERELEMENT_H
 
#include "../Element.h"
#include "../../utils/ElementPlotData.h"
 
enum class ElectricalUnit : int {
    UNIT_PU = 0, 
    UNIT_V,      
    UNIT_kV,     
    UNIT_A,      
    UNIT_kA,     
    UNIT_W,      
    UNIT_kW,     
    UNIT_MW,     
    UNIT_VA,     
    UNIT_kVA,    
    UNIT_MVA,    
    UNIT_var,    
    UNIT_kvar,   
    UNIT_Mvar,   
    UNIT_OHM,    
    UNIT_OHM_km, 
    UNIT_S,      
    UNIT_S_km,   
    UNIT_DEGREE, 
    UNIT_RADIAN,  
    UNIT_NONE
};
 
enum class FaultData : int {
    FAULT_THREEPHASE = 0, 
    FAULT_2LINE,          
    FAULT_2LINE_GROUND,   
    FAULT_LINE_GROUND,    
    FAULT_LINE_A,         
    FAULT_LINE_B,         
    FAULT_LINE_C          
};
 
enum class SwitchingType : int {
    SW_INSERT = 0, 
    SW_REMOVE      
};
 
enum class PowerFlowDirection : int {
    PF_NONE = 0,     
    PF_TO_BUS,       
    PF_TO_ELEMENT,   
    PF_BUS1_TO_BUS2, 
    PF_BUS2_TO_BUS1  
};
 
enum class PlotStudy : int {
    STABILITY = 0, 
    FREQRESPONSE   
};
 
struct SwitchingData {
    std::vector<SwitchingType> swType; 
    std::vector<double> swTime;        
};
 
struct IntegrationConstant {
    double c; 
    double m; 
};
 
class PowerElement : public Element
{
   public:
    PowerElement();
    virtual ~PowerElement() {}
 
    virtual wxPoint2DDouble GetSwitchPoint(Element* parent,
                                           wxPoint2DDouble parentPoint,
                                           wxPoint2DDouble secondPoint) const;
 
    virtual bool SwitchesContains(wxPoint2DDouble position) const;
 
    virtual void UpdateSwitches();
 
    //virtual void DrawSwitches() const;
 
    virtual void DrawDCSwitches(wxGraphicsContext* gc) const;
 
    virtual void DrawDCSwitches(wxDC& dc) const;
 
    virtual void CalculatePowerFlowPts(std::vector<wxPoint2DDouble> edges);
 
    //virtual void DrawPowerFlowPts() const;
 
    virtual void DrawDCPowerFlowPts(wxGraphicsContext* gc) const;
 
    virtual void DrawDCPowerFlowPts(wxDC& dc) const;
 
    virtual void SetNominalVoltage(std::vector<double> nominalVoltage, std::vector<ElectricalUnit> nominalVoltageUnit);
 
    virtual void SetSwitchingData(SwitchingData data) { m_swData = data; }
    virtual SwitchingData GetSwitchingData() { return m_swData; }
    virtual void SetPowerFlowDirection(PowerFlowDirection pfDirection) { m_pfDirection = pfDirection; }
    virtual PowerFlowDirection GetPowerFlowDirection() const { return m_pfDirection; }
    virtual bool GetPlotData(ElementPlotData& plotData, PlotStudy study = PlotStudy::STABILITY) { return false; }
    virtual bool HaveDynamicEvent() const { return m_dynEvent; }
    virtual void SetDynamicEvent(bool dynEvent = true) { m_dynEvent = dynEvent; }
    virtual double GetValueFromUnit(double value, ElectricalUnit valueUnit);
 
    virtual void SaveCADProperties(rapidxml::xml_document<>& doc, rapidxml::xml_node<>* elementNode);
    virtual void SaveSwitchingData(rapidxml::xml_document<>& doc, rapidxml::xml_node<>* electricalNode);
    virtual bool OpenElement(rapidxml::xml_node<>* elementNode, std::vector<Element*> parentList) { return true; }
    virtual bool OpenCADProperties(rapidxml::xml_node<>* elementNode, std::vector<Element*> parentList);
    virtual bool OpenSwitchingData(rapidxml::xml_node<>* electricalNode);
 
   protected:
    SwitchingData m_swData;
    std::vector<std::vector<wxPoint2DDouble> > m_powerFlowArrow;
    PowerFlowDirection m_pfDirection = PowerFlowDirection::PF_NONE;
 
    wxColour m_busColour;
    wxColour m_onlineElementColour;
    wxColour m_offlineElementColour;
    wxColour m_closedSwitchColour;
    wxColour m_openedSwitchColour;
    wxColour m_powerFlowArrowColour;
    wxColour m_dynamicEventColour;
 
    bool m_dynEvent = false;
};
 
#endif  // POWERELEMENT_H