PowerElement.cpp

/*
 *  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/>.
 */
 
#include "PowerElement.h"
#ifdef USING_WX_3_0_X
#include "DegreesAndRadians.h"
#endif
#include <wx/brush.h>
 
PowerElement::PowerElement() : Element()
{
    m_busColour.Set(0, 78, 255, 255);
    m_onlineElementColour.Set(51, 51, 51, 255);
    m_offlineElementColour.Set(128, 128, 128, 255);
    m_closedSwitchColour.Set(0, 102, 0, 255);
    m_openedSwitchColour.Set(255, 26, 26, 255);
    m_powerFlowArrowColour.Set(255, 130, 0, 255);
    m_dynamicEventColour.Set(255, 130, 0, 255);
}
 
void PowerElement::SetNominalVoltage(std::vector<double> nominalVoltage, std::vector<ElectricalUnit> nominalVoltageUnit)
{
}
 
wxPoint2DDouble PowerElement::GetSwitchPoint(Element* parent,
                                             wxPoint2DDouble parentPoint,
                                             wxPoint2DDouble secondPoint) const
{
    double swLineSize = 25.0;
    wxPoint2DDouble swPoint = wxPoint2DDouble(parentPoint.m_x, parentPoint.m_y - swLineSize);
 
    // Rotate the second point (to compare).
    double angle = parent->GetAngle();
 
    secondPoint =
        wxPoint2DDouble(std::cos(wxDegToRad(-angle)) * (secondPoint.m_x - parentPoint.m_x) -
                            std::sin(wxDegToRad(-angle)) * (secondPoint.m_y - parentPoint.m_y) + parentPoint.m_x,
                        std::sin(wxDegToRad(-angle)) * (secondPoint.m_x - parentPoint.m_x) +
                            std::cos(wxDegToRad(-angle)) * (secondPoint.m_y - parentPoint.m_y) + parentPoint.m_y);
 
    // Rotate
    if(secondPoint.m_y > parentPoint.m_y) angle -= 180.0;
    return wxPoint2DDouble(std::cos(wxDegToRad(angle)) * (swPoint.m_x - parentPoint.m_x) -
                               std::sin(wxDegToRad(angle)) * (swPoint.m_y - parentPoint.m_y) + parentPoint.m_x,
                           std::sin(wxDegToRad(angle)) * (swPoint.m_x - parentPoint.m_x) +
                               std::cos(wxDegToRad(angle)) * (swPoint.m_y - parentPoint.m_y) + parentPoint.m_y);
}
 
bool PowerElement::SwitchesContains(wxPoint2DDouble position) const
{
    for(int i = 0; i < (int)m_switchRect.size(); i++) {
        if(m_parentList[i]) {
            if(m_switchRect[i].Contains(position)) return true;
        }
    }
    return false;
}
 
void PowerElement::UpdateSwitches()
{
    // General method, to one switch only.
    wxPoint2DDouble swCenter = wxPoint2DDouble((m_pointList[0].m_x + m_pointList[1].m_x) / 2.0,
                                               (m_pointList[0].m_y + m_pointList[1].m_y) / 2.0);
    m_switchRect[0] = wxRect2DDouble(swCenter.m_x - m_switchSize / 2.0, swCenter.m_y - m_switchSize / 2.0, m_switchSize,
                                     m_switchSize);
}
 
//void PowerElement::DrawSwitches() const
//{
//    int i = 0;
//    for(auto it = m_parentList.begin(); it != m_parentList.end(); it++) {
//        Element* parent = *it;
//        if(parent) {
//            if(m_online) {
//                glColor4dv(m_closedSwitchColour);
//            } else {
//                glColor4dv(m_openedSwitchColour);
//            }
//
//            glPushMatrix();
//            glTranslated(m_switchRect[i].GetPosition().m_x + m_switchSize / 2.0,
//                         m_switchRect[i].GetPosition().m_y + m_switchSize / 2.0, 0.0);
//            glRotated(parent->GetAngle(), 0.0, 0.0, 1.0);
//            glTranslated(-m_switchRect[i].GetPosition().m_x - m_switchSize / 2.0,
//                         -m_switchRect[i].GetPosition().m_y - m_switchSize / 2.0, 0.0);
//
//            DrawRectangle(m_switchRect[i].GetPosition() + wxPoint2DDouble(m_switchSize / 2.0, m_switchSize / 2.0),
//                          m_switchSize, m_switchSize);
//
//            glPopMatrix();
//        }
//        i++;
//    }
//}
 
void PowerElement::DrawDCSwitches(wxGraphicsContext* gc) const
{
    gc->SetPen(*wxTRANSPARENT_PEN);
    
    int i = 0;
    for (auto parent : m_parentList) {
        if (parent) {
            if (m_online) {
                gc->SetBrush(wxBrush(m_closedSwitchColour));
            }
            else {
                gc->SetBrush(wxBrush(m_openedSwitchColour));
            }
 
            gc->PushState();
            gc->Translate(m_switchRect[i].GetPosition().m_x + m_switchSize / 2.0,
                m_switchRect[i].GetPosition().m_y + m_switchSize / 2.0);
            gc->Rotate(wxDegToRad(parent->GetAngle()));
            gc->Translate(-m_switchRect[i].GetPosition().m_x - m_switchSize / 2.0,
                -m_switchRect[i].GetPosition().m_y - m_switchSize / 2.0);
 
            wxPoint2DDouble switchPos = m_switchRect[i].GetPosition();
            gc->DrawRectangle(switchPos.m_x, switchPos.m_y, m_switchSize, m_switchSize);
 
            gc->PopState();
        }
        i++;
    }
}
 
void PowerElement::DrawDCSwitches(wxDC& dc) const
{
    dc.SetPen(*wxTRANSPARENT_PEN);
 
    int i = 0;
    for (auto parent : m_parentList) {
        if (parent) {
            if (m_online) {
                dc.SetBrush(wxBrush(m_closedSwitchColour));
            }
            else {
                dc.SetBrush(wxBrush(m_openedSwitchColour));
            }
 
            //gc->PushState();
            //gc->Translate(m_switchRect[i].GetPosition().m_x + m_switchSize / 2.0,
            //    m_switchRect[i].GetPosition().m_y + m_switchSize / 2.0);
            //gc->Rotate(wxDegToRad(parent->GetAngle()));
            //gc->Translate(-m_switchRect[i].GetPosition().m_x - m_switchSize / 2.0,
            //    -m_switchRect[i].GetPosition().m_y - m_switchSize / 2.0);
            //
            //wxPoint2DDouble switchPos = m_switchRect[i].GetPosition();
            //gc->DrawRectangle(switchPos.m_x, switchPos.m_y, m_switchSize, m_switchSize);
            //
            //gc->PopState();
 
            DrawDCRectangle(m_switchRect[i].GetPosition() + wxPoint2DDouble(m_switchSize / 2.0, m_switchSize / 2.0),
                m_switchSize, m_switchSize, parent->GetAngle(), dc);
        }
        i++;
    }
}
 
void PowerElement::CalculatePowerFlowPts(std::vector<wxPoint2DDouble> edges)
{
    double arrowRate = 100.0;  // One arrow to each "arrowRate" distance in pixels.
 
    if(edges.size() < 2) return;
 
    // Clear all power flow points
    for(int i = 0; i < (int)m_powerFlowArrow.size(); i++) m_powerFlowArrow[i].clear();
    m_powerFlowArrow.clear();
 
    for(int i = 1; i < (int)edges.size(); i++) {
        wxPoint2DDouble pt1 = edges[i - 1];
        wxPoint2DDouble pt2 = edges[i];
 
        double angle = std::atan2(pt2.m_y - pt1.m_y, pt2.m_x - pt1.m_x);
 
        wxPoint2DDouble rotPt2(
            std::cos(-angle) * (pt2.m_x - pt1.m_x) - std::sin(-angle) * (pt2.m_y - pt1.m_y) + pt1.m_x,
            std::sin(-angle) * (pt2.m_x - pt1.m_x) + std::cos(-angle) * (pt2.m_y - pt1.m_y) + pt1.m_y);
 
        int numArrows = std::abs(pt1.m_x - rotPt2.m_x) / arrowRate;
        if(numArrows == 0) numArrows = 1;
 
        for(int i = 0; i < numArrows; i++) {
            wxPoint2DDouble arrowCenter(pt1.m_x + ((rotPt2.m_x - pt1.m_x) / double(numArrows + 1)) * double(i + 1),
                                        pt1.m_y + ((rotPt2.m_y - pt1.m_y) / double(numArrows + 1)) * double(i + 1));
 
            std::vector<wxPoint2DDouble> triPts;
            triPts.push_back(arrowCenter + wxPoint2DDouble(5.0, 0.0));
            triPts.push_back(arrowCenter + wxPoint2DDouble(-5.0, 5.0));
            triPts.push_back(arrowCenter + wxPoint2DDouble(-5.0, -5.0));
 
            // Rotate back.
            for(int i = 0; i < 3; i++) {
                triPts[i] = wxPoint2DDouble(
                    std::cos(angle) * (triPts[i].m_x - pt1.m_x) - std::sin(angle) * (triPts[i].m_y - pt1.m_y) + pt1.m_x,
                    std::sin(angle) * (triPts[i].m_x - pt1.m_x) + std::cos(angle) * (triPts[i].m_y - pt1.m_y) +
                        pt1.m_y);
            }
            m_powerFlowArrow.push_back(triPts);
        }
    }
}
 
//void PowerElement::DrawPowerFlowPts() const
//{
//    if(m_online) {
//        glColor4dv(m_powerFlowArrowColour.GetRGBA());
//        for(int i = 0; i < (int)m_powerFlowArrow.size(); i++) { DrawTriangle(m_powerFlowArrow[i]); }
//    }
//}
 
void PowerElement::DrawDCPowerFlowPts(wxGraphicsContext* gc) const
{
    gc->SetPen(*wxTRANSPARENT_PEN);
    if (m_online) {
        gc->SetBrush(wxBrush(m_powerFlowArrowColour));
        for (auto arrow : m_powerFlowArrow) { DrawDCTriangle(arrow, gc); }
    }
}
 
void PowerElement::DrawDCPowerFlowPts(wxDC& dc) const
{
    dc.SetPen(*wxTRANSPARENT_PEN);
    if (m_online) {
        dc.SetBrush(wxBrush(m_powerFlowArrowColour));
        for (auto arrow : m_powerFlowArrow) { 
            std::vector<wxPoint> arrowPts;
            for (auto& pt : arrow) {
                arrowPts.emplace_back(static_cast<int>(pt.m_x), static_cast<int>(pt.m_y));
            }
            DrawDCTriangle(arrowPts, dc);
        }
    }
}
 
double PowerElement::GetValueFromUnit(double value, ElectricalUnit valueUnit)
{
    switch(valueUnit) {
        case ElectricalUnit::UNIT_kV:
        case ElectricalUnit::UNIT_kA:
        case ElectricalUnit::UNIT_kW:
        case ElectricalUnit::UNIT_kVA:
        case ElectricalUnit::UNIT_kvar: {
            return value * 1e3;
        } break;
        case ElectricalUnit::UNIT_MW:
        case ElectricalUnit::UNIT_MVA:
        case ElectricalUnit::UNIT_Mvar: {
            return value * 1e6;
        }
        default:
            break;
    }
    return value;
}
 
bool PowerElement::OpenCADProperties(rapidxml::xml_node<>* elementNode, std::vector<Element*> parentList)
{
    auto cadPropNode = elementNode->first_node("CADProperties");
    if(!cadPropNode) return false;
 
    auto position = cadPropNode->first_node("Position");
    double posX = XMLParser::GetNodeValueDouble(position, "X");
    double posY = XMLParser::GetNodeValueDouble(position, "Y");
    auto size = cadPropNode->first_node("Size");
    m_width = XMLParser::GetNodeValueDouble(size, "Width");
    m_height = XMLParser::GetNodeValueDouble(size, "Height");
    double angle = XMLParser::GetNodeValueDouble(cadPropNode, "Angle");
    SetPosition(wxPoint2DDouble(posX, posY));
 
    auto nodePosition = cadPropNode->first_node("NodePosition");
    double nodePosX = XMLParser::GetNodeValueDouble(nodePosition, "X");
    double nodePosY = XMLParser::GetNodeValueDouble(nodePosition, "Y");
 
    int parentID = XMLParser::GetNodeValueInt(cadPropNode, "ParentID");
    // If the opened power element has no parent, set up the basics CAD properties of the element manually, otherwise
    // just class method AddParent to calculate properly.
    if(parentID == -1) {
        m_parentList.push_back(nullptr);
        m_pointList.push_back(wxPoint2DDouble(nodePosX, nodePosY));
        m_pointList.push_back(wxPoint2DDouble(nodePosX, nodePosY));
        m_pointList.push_back(m_position + wxPoint2DDouble(0.0, -m_height / 2.0 - 10.0));
        m_pointList.push_back(m_position + wxPoint2DDouble(0.0, -m_height / 2.0));
 
        wxRect2DDouble genRect(0, 0, 0, 0);
        m_switchRect.push_back(genRect);  // Push a general rectangle.
        UpdateSwitches();
 
        m_online = false;  // Not connected elements are always offline.
    } else {
        AddParent(parentList[parentID], wxPoint2DDouble(nodePosX, nodePosY));
    }
 
    // Set up the points properly.
    StartMove(m_position);
    Move(wxPoint2DDouble(posX, posY));
 
    // Set the rotation properly.
    int numRot = angle / m_rotationAngle;
    bool clockwise = true;
    if(numRot < 0) {
        numRot = std::abs(numRot);
        clockwise = false;
    }
    for(int i = 0; i < numRot; i++) Rotate(clockwise);
 
    return true;
}
 
void PowerElement::SaveCADProperties(rapidxml::xml_document<>& doc, rapidxml::xml_node<>* elementNode)
{
    auto cadProp = XMLParser::AppendNode(doc, elementNode, "CADProperties");
    auto position = XMLParser::AppendNode(doc, cadProp, "Position");
    auto posX = XMLParser::AppendNode(doc, position, "X");
    XMLParser::SetNodeValue(doc, posX, m_position.m_x);
    auto posY = XMLParser::AppendNode(doc, position, "Y");
    XMLParser::SetNodeValue(doc, posY, m_position.m_y);
    auto size = XMLParser::AppendNode(doc, cadProp, "Size");
    auto width = XMLParser::AppendNode(doc, size, "Width");
    XMLParser::SetNodeValue(doc, width, m_width);
    auto height = XMLParser::AppendNode(doc, size, "Height");
    XMLParser::SetNodeValue(doc, height, m_height);
    auto angle = XMLParser::AppendNode(doc, cadProp, "Angle");
    XMLParser::SetNodeValue(doc, angle, m_angle);
    auto nodePos = XMLParser::AppendNode(doc, cadProp, "NodePosition");
    auto nodePosX = XMLParser::AppendNode(doc, nodePos, "X");
    XMLParser::SetNodeValue(doc, nodePosX, m_pointList[0].m_x);
    auto nodePosY = XMLParser::AppendNode(doc, nodePos, "Y");
    XMLParser::SetNodeValue(doc, nodePosY, m_pointList[0].m_y);
    auto parentID = XMLParser::AppendNode(doc, cadProp, "ParentID");
    Element* parent = m_parentList[0];
    if(parent) XMLParser::SetNodeValue(doc, parentID, parent->GetID());
}
 
void PowerElement::SaveSwitchingData(rapidxml::xml_document<>& doc, rapidxml::xml_node<>* electricalNode)
{
    auto switchingList = XMLParser::AppendNode(doc, electricalNode, "SwitchingList");
    for(int i = 0; i < static_cast<int>(m_swData.swType.size()); i++) {
        auto switching = XMLParser::AppendNode(doc, switchingList, "Switching");
        XMLParser::SetNodeAttribute(doc, switching, "ID", i);
        auto swType = XMLParser::AppendNode(doc, switching, "Type");
        XMLParser::SetNodeValue(doc, swType, static_cast<int>(m_swData.swType[i]));
        auto swTime = XMLParser::AppendNode(doc, switching, "Time");
        XMLParser::SetNodeValue(doc, swTime, m_swData.swTime[i]);
    }
}
 
bool PowerElement::OpenSwitchingData(rapidxml::xml_node<>* electricalNode)
{
    auto switchingList = electricalNode->first_node("SwitchingList");
    if(!switchingList) return false;
    auto swNode = switchingList->first_node("Switching");
    while(swNode) {
        m_swData.swType.push_back((SwitchingType)XMLParser::GetNodeValueInt(swNode, "Type"));
        m_swData.swTime.push_back(XMLParser::GetNodeValueDouble(swNode, "Time"));
        swNode = swNode->next_sibling("Switching");
    }
    return true;
}