ImportForm.h

Go to the documentation of this file.

/*
 *  Copyright (C) 2018  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 IMPORTFORM_H
#define IMPORTFORM_H
 
#include "PropertiesFormBase.h"
 
#include <wx/geometry.h>
#include <wx/msgdlg.h>
#include <wx/textfile.h>
#include <wx/tokenzr.h>
#include <bitset>
#include <complex>
 
class Workspace;
class Bus;
class SyncGenerator;
class SyncMotor;
class Load;
class Capacitor;
class Inductor;
class Capacitor;
class IndMotor;
class Transformer;
class Line;
class PropertiesData;
 
class GraphAutoLayout;
 
class ImportForm : public ImportFormBase
{
   public:
    ImportForm(wxWindow* parent, Workspace* workspace);
    virtual ~ImportForm();
 
    Workspace* GetWorkspace() { return m_workspace; }
 
   protected:
    virtual void OnButtonCancelClick(wxCommandEvent& event);
    virtual void OnButtonOKClick(wxCommandEvent& event);
    bool ImportSelectedFiles();
    bool ImportCEPELFiles();
    bool ImportMatpowerFiles();
    Bus* GetBusFromID(std::vector<Bus*> busList, int id);
 
    Workspace* m_workspace = nullptr;
    wxWindow* m_parent;
};
 
enum ElementTypeAnarede {
    ANA_BUS = 1,            
    ANA_GENERATOR = 4,      
    ANA_LOAD = 5,           
    ANA_SHUNT = 6,          
    ANA_MIT = 7,            
    ANA_TRANSFORMER = 9,    
    ANA_LINE = 14,          
    ANA_IND_LOAD = 22,      
    ANA_IND_SHUNT = 23,     
    ANA_IND_GENERATOR = 24, 
};
 
class ParseAnarede
{
   public:
    // Graphic files data structs
    struct Component {
        int id = 0;                        
        ElementTypeAnarede type = ANA_BUS; 
        double length = 0.0;               
        int rotationID = 0;                
        wxPoint2DDouble position;          
        int electricalID = 0;              
        std::pair<int, int> busConnectionID[2] = {
            std::make_pair(0, 0), std::make_pair(0, 0)}; 
        std::pair<int, int> busConnectionNode[2] = {std::make_pair(0, 0),
                                                    std::make_pair(0, 0)}; 
    };
    struct PowerLine {
        int id = 0;                         
        ElementTypeAnarede type = ANA_LINE; 
        int electricalID = 0;               
        std::pair<int, int> busConnectionID[2] = {
            std::make_pair(0, 0), std::make_pair(0, 0)}; 
        std::pair<int, int> busConnectionNode[2] = {std::make_pair(0, 0),
                                                    std::make_pair(0, 0)}; 
        std::vector<wxPoint2DDouble> nodesPosition; 
    };
    struct BusData {
        int id = 0;                 
        bool isOnline = true;       
        int type = 0;               
        wxString voltageBase = "0"; 
        wxString busName = "Bus";   
        double voltage = 1.0;       
        double angle = 0.0;         
        std::complex<double> genPower = std::complex<double>(0, 0);  
        double minReactivePower = -9999.0;                           
        double maxReactivePower = 99999.0;                           
        int ctrlBusID = 0;                                           
        std::complex<double> loadPower = std::complex<double>(0, 0); 
        double shuntReactive =
            0.0; 
    };
    struct BranchData {
        int id = 0;                                                
        ElementTypeAnarede type = ANA_LINE;                        
        std::pair<int, int> busConnections = std::make_pair(0, 0); 
        bool isOnline = true;                                      
        double resistance = 0.0;                                   
        double indReactance = 0.0;                                 
        double capSusceptance = 0.0;                               
        double tap = 0.0;                                          
        double phaseShift = 0.0;                                   
    };
    struct IndElementData {
        int id = 0;                                              
        int busConnection = 0;                                   
        ElementTypeAnarede type = ANA_IND_GENERATOR;             
        bool isOnline = true;                                    
        std::complex<double> power = std::complex<double>(0, 0); 
        int numUnits = 0;                                        
    };
    struct IndGenData : IndElementData {
        double minReactivePower = -9999.0; 
        double maxReactivePower = 99999.0; 
        double xt = 1.0;                   
        double xd = 1.0;                   
        double xq = 1.0;                   
        double xl = 1.0;                   
        double ratedPower = 100.0;         
    };
 
    ParseAnarede(wxFileName lstFile, wxFileName pwfFile);
    ~ParseAnarede() { ClearData(); }
 
    bool Parse();
 
    std::vector<Component*> GetComponents() const { return m_components; }
    std::vector<PowerLine*> GetLines() const { return m_lines; }
    std::vector<BranchData*> GetBranchData() const { return m_branchData; }
    std::vector<BusData*> GetBusData() const { return m_busData; }
    std::vector<IndElementData*> GetIndElementData() const { return m_indElementData; }
    wxString GetProjectName() const { return m_projectName; }
    double GetMVAPowerBase() const { return m_mvaBase; }
 
    wxPoint2DDouble GetNodePositionFromID(Bus* bus, double scale, int nodeID);
    BusData* GetBusDataFromID(int id);
    BranchData* GetBranchDataFromID(int id, int fromBus, int toBus, ElementTypeAnarede type);
    IndElementData* GetIndElementDataFromID(int id, int busID, ElementTypeAnarede type);
 
    void ClearData();
 
   protected:
    bool GetLenghtAndRotationFromBusCode(wxString code, double& lenght, int& rotationID);
    wxString GetLSTLineNextValue(wxString line, int& currentPos);
    bool StrToElementType(wxString strType, ElementTypeAnarede& type);
    bool ParsePWFExeCode(wxString data, wxString exeCode);
    bool GetPWFStructuredData(wxString data,
                              unsigned int startPos,
                              unsigned int dataLenght,
                              int& value,
                              int decimalPos = -1);
    bool GetPWFStructuredData(wxString data,
                              unsigned int startPos,
                              unsigned int dataLenght,
                              double& value,
                              int decimalPos = -1);
 
    wxFileName m_lstFile;
    wxFileName m_pwfFile;
 
    std::vector<Component*> m_components;
    std::vector<PowerLine*> m_lines;
    std::vector<BusData*> m_busData;
    std::vector<BranchData*> m_branchData;
    std::vector<IndElementData*> m_indElementData;
 
    wxString m_projectName = _("Imported project");
    double m_mvaBase = 100.0;
};
 
class ParseMatpower
{
   public:
    struct BusData {
        int id = 0;      
        int type = 0;    
        double pd = 0.0; 
        double qd = 0.0; 
        double gs = 0.0; 
        double bs = 0.0; 
        int area = 0;    
        double voltage = 1.0;     
        double angle = 0.0;       
        double baseVoltage = 138; 
        wxString busName = "Bus"; 
        wxPoint2DDouble busPosition = wxPoint2DDouble(0,0);  
    };
    struct GenData {
        int busID = 0;                     
        double pg = 0.0;                   
        double qg = 0.0;                   
        double maxReactivePower = 99999.0; 
        double minReactivePower = -9999.0; 
        double baseMVA = 100;              
        bool isOnline = true; 
    };
    struct BranchData {
        std::pair<int, int> busConnections = std::make_pair(0, 0); 
        double resistance = 0.0;                                   
        double indReactance = 0.0;                                 
        double capSusceptance = 0.0;                               
        double tap = 0.0;        
        double phaseShift = 0.0; 
        bool isOnline = true;    
    };
 
    ParseMatpower(wxFileName mFile);
    ~ParseMatpower() { ClearData(); }
 
    void ClearData();
 
    bool Parse();
    
    std::vector<BranchData*> GetBranchData() const { return m_branchData; }
    std::vector<BusData*> GetBusData() const { return m_busData; }
    std::vector<GenData*> GetGenData() const { return m_genData; }
    double GetMVAPowerBase() const { return m_mvaBase; }
    
    BusData* GetBusDataFromID(int id);
    Bus* GetBusFromID(int id, std::vector<Bus*> busList);
 
   protected:
    wxStringTokenizer GetMFileTokenData(wxTextFile& mFile, wxString currentLine);
    wxFileName m_mFile;
 
    std::vector<BusData*> m_busData;
    std::vector<BranchData*> m_branchData;
    std::vector<GenData*> m_genData;
 
    wxString m_projectName = _("Imported project");
    double m_mvaBase = 100.0;
};
 
#endif  // IMPORTFORM_H