cimforreduceloss/core/topology.cpp

#include "head.h"
#include <QStringRef>

//extern vector<QString> ResContainer;
//extern vector<QString> Notfound;
//extern QString cn;
//extern int bus_no;
//extern int balance_node;
//extern int k;
#include "qt_readxml.h"
void Qt_readxml::XmlReaderTopologyAnalyse()

{
    k=0;
    bus_no=busbar_section.size();
    int terminal_no=terminal.size();
    ResContainer.clear();
    Notfound.clear();
    for (int i=0;i<terminal_no;i++ )
    {
        ResContainer.push_back(terminal[i].ConductingEquipment_res[0]);
        ResContainer.push_back(terminal[i].ConnectivityNode_res[0]);
        QString type;
        int res_no=ResContainer.size();
        for (int j=0;j<res_no;j++)
        {
            std::vector<List>::iterator it = find_if(list1.begin(), list1.end(), vector_finder(ResContainer[0].remove(0,1)));                //得到与ID号相对应的元素
            if(it!=list1.end())
            {
                QString a;
                type=it->name;
                if (type=="busbar_section")
                {
                    busbar_section[it->no].Terminal_res.push_back(terminal[i].ID);
                }
                else if (type=="substation")
                {
                    substation[it->no].Terminal_res.push_back(terminal[i].ID);
                }
                else if (type=="connectivity_node")
                {
                    connectivity_node[it->no].Terminal_res.push_back(terminal[i].ID);
                }
                else if (type=="acline_segment")
                {
                    acline_segment[it->no].Terminal_res.push_back(terminal[i].ID);
                }
                else if (type=="disconnector")
                {
                    disconnector[it->no].Terminal_res.push_back(terminal[i].ID);
                }
                else if (type=="power_transformer")
                {
                    power_transformer[it->no].Terminal_res.push_back(terminal[i].ID);
                }
                else if (type=="transformer_winding")
                {
                    transformer_winding[it->no].Terminal_res.push_back(terminal[i].ID);
                }
                else if (type=="ground_disconnector")
                {
                    ground_disconnector[it->no].Terminal_res.push_back(terminal[i].ID);
                }
                else if (type=="composite_switch")
                {
                    composite_switch[it->no].Terminal_res.push_back(terminal[i].ID);
                }
                else if (type=="circuit")
                {
                    circuit[it->no].Terminal_res.push_back(terminal[i].ID);
                }
                else if (type=="bay")
                {
                    bay[it->no].Terminal_res.push_back(terminal[i].ID);
                }
                else if (type=="connector")
                {
                    connector[it->no].Terminal_res.push_back(terminal[i].ID);
                }
                else if (type=="fuse")
                {
                    fuse[it->no].Terminal_res.push_back(terminal[i].ID);
                }
                else if (type=="pole")
                {
                    pole[it->no].Terminal_res.push_back(terminal[i].ID);
                }
                else if (type=="load_break_switch")
                {
                    load_break_switch[it->no].Terminal_res.push_back(terminal[i].ID);
                }
                else if (type=="breaker")
                {
                    breaker[it->no].Terminal_res.push_back(terminal[i].ID);
                }
            }
            //else if(ResContainer[0].left(2)=="CN")
            else
            {
                ConnectivityNode CN;
                CN.ID = ResContainer[0];
                CN.Terminal_res.push_back(terminal[i].ID);
                CN.flag = 0;
                connectivity_node.push_back(CN);
                QString name="connectivity_node";
                XmlReaderFormList(i5,name,CN.ID);
                i5++;
                Notfound.push_back(ResContainer[0]);
            }

            ResContainer.erase(ResContainer.begin());
        }
    }
    int i=0;
    if (!bus_no)
    {
        BusbarSection T1;
        T1.flag=0;
        T1.BaseVoltage_res.push_back(acline_segment[i].BaseVoltage_res[0]);
        T1.Terminal_res.push_back(acline_segment[i].Terminal_res[0]);
        T1.busSequence=0;
        busbar_section.push_back(T1);
        bus_no++;
    }
    int ac_no=acline_segment.size();

    for (int i=0;i<ac_no;i++)
    {
        std::vector<AC_kind>::iterator it = find_if(ac_kind.begin(), ac_kind.end(), ac_finder(acline_segment[i].GIS_ID));                //得到与ID号相对应的元素
        if(it==ac_kind.end())
        {
            AC_kind A;
            A.GIS_ID=acline_segment[i].GIS_ID;
            A.quantity=1;
            A.calculateTimes=0;
            ac_kind.push_back(A);
        }
        else
        {
            (it->quantity)++;
        }
    }

    int j=0;
    for (i=0;i<bus_no;i++)
    {
        if (!busbar_section[i].flag && busbar_section[i].Terminal_res.size())
        {
            j++;          //拓扑岛编号
            int n=1;      //节点编号
            busbar_section[i].flag=1;
            busbar_section[i].island=j;
            int sign=0;     //sign=0表示有对线路或变压器编号
            int res_no=busbar_section[i].Terminal_res.size();
            for (int m=0;m<res_no;m++)
            {
                ResContainer.push_back(busbar_section[i].Terminal_res[m]);
            }
            sign=XmlReaderFindResource(j,n,sign);
            while (nextBus.size())
            {
                ResContainer.push_back(nextBus[0]);
                nextBus.erase(nextBus.begin());
                n=n+1-sign;
                sign=1;
                sign=XmlReaderFindResource(j,n,sign);
            }
        }
    }
}

int Qt_readxml::XmlReaderFindResource(int j, int n,int sign)
{
    QString type;
    int res_no=ResContainer.size();
    for (int i=0;i<res_no;i++)
    {
        std::vector<List>::iterator it = find_if(list1.begin(), list1.end(), vector_finder(ResContainer[0]));                //得到与ID号相对应的元素
        ResContainer.erase(ResContainer.begin());
        if(it!=list1.end())
        {
            type=it->name;
            if (type=="terminal" && !terminal[it->no].flag)
            {
                terminal[it->no].flag=n;
                terminal[it->no].island=j;
                ResContainer.push_back(terminal[it->no].ConductingEquipment_res[0].remove(0,1));
                ResContainer.push_back(terminal[it->no].ConnectivityNode_res[0].remove(0,1));
            }

            else if (type=="connectivity_node" && !connectivity_node[it->no].flag)
            {
                connectivity_node[it->no].flag=n;
                connectivity_node[it->no].island = j;
                int no1=connectivity_node[it->no].Terminal_res.size();
                if (no1)
                {
                    for (int m=0;m<no1;m++)
                    {
                        ResContainer.push_back(connectivity_node[it->no].Terminal_res[m]);
                    }
                }
            }

            else if (type=="acline_segment")
            {
                isAcnode = 0;
                acline_segment[it->no].island=j;
                if (!acline_segment[it->no].link_from)
                {
                    acline_segment[it->no].link_from=n;
                    nextBus.push_back(acline_segment[it->no].ID);
                    sign=0;
                }
                else if (!acline_segment[it->no].link_to)
                {
                    int no1=acline_segment[it->no].Terminal_res.size();
                    if (no1)
                    {
                        for (int m=0;m<no1;m++)
                        {
                            ResContainer.push_back(acline_segment[it->no].Terminal_res[m]);
                        }
                    }
                    acline_segment[it->no].link_to=n;
                    sign=0;
                    std::vector<AC_kind>::iterator ac = find_if(ac_kind.begin(), ac_kind.end(), ac_finder(acline_segment[it->no].GIS_ID));
                    (ac->calculateTimes)++;
                }
            }

            else if (type=="load_break_switch" && !load_break_switch[it->no].flag)
            {
                load_break_switch[it->no].flag=n;
                load_break_switch[it->no].island=j;
                int no1=load_break_switch[it->no].Terminal_res.size();
                if (no1)
                {
                    for (int m=0;m<no1;m++)
                    {
                        ResContainer.push_back(load_break_switch[it->no].Terminal_res[m]);
                    }
                }

            }

            else if (type=="disconnector" && !disconnector[it->no].flag)
            {
                disconnector[it->no].flag=n;
                disconnector[it->no].island=j;
                int no1=disconnector[it->no].Terminal_res.size();
                if (no1)
                {
                    for (int m=0;m<no1;m++)
                    {
                        ResContainer.push_back(disconnector[it->no].Terminal_res[m]);
                    }
                }
            }

            else if (type=="transformer_winding"&& !transformer_winding[it->no].flag)
            {
                isAcnode = 0;
                int a=transformer_winding[it->no].MemberOf_PowerTransformer_res[0].length();
                QString b=transformer_winding[it->no].MemberOf_PowerTransformer_res[0];
                std::vector<List>::iterator trans = find_if(list1.begin(), list1.end(), vector_finder(b.right(a-1)));
                transformer_winding[it->no].island = j;
                transformer_winding[it->no].flag = n;
                if (!power_transformer[trans->no].link_1)
                {
                    power_transformer[trans->no].link_1=n;
                    power_transformer[trans->no].island=j;
                    sign=0;
                    //isAcnode = 0;
                    if (transformer_winding[it->no].description=="低压侧绕组")
                    {
                        power_transformer[trans->no].low=n;
                    }
                    int winding_no=transformer_winding.size();
                    for (int m=0;m<winding_no;m++)
                    {
                        if (transformer_winding[m].MemberOf_PowerTransformer_res[0]==b && m!=(it->no))
                        {
                            nextBus.push_back(transformer_winding[m].ID);
                        }
                    }
                }
                else if (!power_transformer[trans->no].link_2&&power_transformer[trans->no].link_1!=n)
                {
                    power_transformer[trans->no].link_2=n;
                    sign=0;
                    //isAcnode = 0;
                    if (transformer_winding[it->no].description=="低压侧绕组")
                    {
                        power_transformer[trans->no].low=n;
                    }
                    if (transformer_winding[it->no].Terminal_res.size())
                    {
                        ResContainer.push_back(transformer_winding[it->no].Terminal_res[0]);
                    }
                }
                else if (!power_transformer[trans->no].link_3&&power_transformer[trans->no].link_2!=n &&power_transformer[trans->no].link_1!=n)
                {
                    power_transformer[trans->no].link_3=n;
                    sign=0;
                    //isAcnode = 0;
                    if (transformer_winding[it->no].description=="低压侧绕组")
                    {
                        power_transformer[trans->no].low=n;
                    }
                    if (transformer_winding[it->no].Terminal_res.size())
                    {
                        ResContainer.push_back(transformer_winding[it->no].Terminal_res[0]);
                    }
                }
            }

            else if (type=="connector" && !connector[it->no].flag)
            {
                connector[it->no].link_from=n;
                connector[it->no].island=j;
                int no1=connector[it->no].Terminal_res.size();
                if (no1)
                {
                    for (int m=0;m<no1;m++)
                    {
                        ResContainer.push_back(connector[it->no].Terminal_res[m]);
                    }

                }
            }

            else if (type=="fuse" && !fuse[it->no].flag)
            {
                fuse[it->no].flag=n;
                fuse[it->no].island=j;
                int no1=fuse[it->no].Terminal_res.size();
                if (no1)
                    for (int m=0;m<no1;m++)
                    {
                        ResContainer.push_back(fuse[it->no].Terminal_res[m]);
                    }
            }

            else if (type=="ground_disconnector" && !ground_disconnector[it->no].flag)
            {
                ground_disconnector[it->no].flag=n;
                ground_disconnector[it->no].island=j;
                int no1=ground_disconnector[it->no].Terminal_res.size();
                for (int m=0;m<no1;m++)
                {
                    ResContainer.push_back(ground_disconnector[it->no].Terminal_res[m]);
                }
            }

            else if (type=="breaker" && !breaker[it->no].flag)
            {
                breaker[it->no].flag=n;
                breaker[it->no].island=j;
                int no1=breaker[it->no].Terminal_res.size();
                if (no1)
                {
                    for (int m=0;m<no1;m++)
                    {
                        ResContainer.push_back(breaker[it->no].Terminal_res[m]);
                    }
                }
            }
            else if (type=="busbar_section" && !busbar_section[it->no].flag)
            {
                int no1=busbar_section[it->no].Terminal_res.size();
                if (no1)
                {
                    for (int m=0;m<no1;m++)
                    {
                        ResContainer.push_back(busbar_section[it->no].Terminal_res[m]);
                    }
                }
                busbar_section[it->no].flag=n;
                busbar_section[it->no].island=j;
                //balance_node=n;
            }
        }
    }
    while (ResContainer.size())
    {
        XmlReaderFindResource(j,n,sign);
    }
    return sign;
}