コード例 #1
0
        // define nova chave NA, entre as chaves NFs
        private string DefineNovaChaveNA(Switch chaveNAinicial)
        {
            /* // DEBUG
             * // mensagem ao usuario
             * _janela.ExibeMsgDisplayMW("Análise ChaveNA: " + chaveNAinicial.nome);
             * */

            // obtem lstChaves no ciclo da chaveNA analisada
            bool ret = _grafo.MenorCaminho(chaveNAinicial);

            // copia o resultado do caso para para a analisa da chave NA.
            _MelhorResultadoPorNA = new PFResults(_resCasoBase);

            // nova chaveNA
            string nomeNovaChaveNA = null;

            // se obteve menor caminho ate a fonte
            if (ret)
            {
                // analisa caminho1
                nomeNovaChaveNA = AnalisaChavesNF(_grafo._lstNomeChavesNFcam1, chaveNAinicial);

                // se nao otimizou, analisa chaves NF reverso
                if (nomeNovaChaveNA == null)
                {
                    // inverte caminho do grafo
                    _grafo._lstNomeChavesNFcam1.Reverse();

                    nomeNovaChaveNA = AnalisaChavesNF(_grafo._lstNomeChavesNFcam1, chaveNAinicial);
                }
            }

            return(nomeNovaChaveNA);
        }
コード例 #2
0
        //funcao gravaPerdas em arquivo
        static public void GravaPerdas(PFResults perdasTotais, string nomeAlim, string fid, MainWindow jan)
        {
            // cria string com o formato de saida das perdas
            string conteudo = perdasTotais._energyMeter.FormataResultado(nomeAlim);

            //Grava em arquivo
            TxtFile.GravaEmArquivo(conteudo, fid, jan);
        }
コード例 #3
0
        public MonthlyPowerFlow(GeneralParameters paramGerais, MainWindow janela, ObjDSS oDSS)
        {
            // preenche variaveis da classe
            _paramGerais = paramGerais;
            _janela      = janela;

            // fluxo dia util
            _fluxoDU = new DailyFlow(paramGerais, janela, oDSS, "DU");

            // fluxo sabado
            _fluxoSA = new DailyFlow(paramGerais, janela, oDSS, "SA");

            // fluxo domingo
            _fluxoDO = new DailyFlow(paramGerais, janela, oDSS, "DO");

            // instancia obj resultado Mensal
            _resFluxoMensal = new PFResults();
        }
コード例 #4
0
        // avalia fluxo de potencia para cada chavesNF da lista.
        private bool AvaliaFluxoPot(Switch chaveNA)
        {
            // resolve circuito
            //_fluxoMensal.ExecutaFluxoMensal();
            _fluxoMensal.ExecutaFluxoMensalSimples();

            double novaPerdas_kWh = double.PositiveInfinity;
            double novaEnergForn_kWh;
            double relacaoEnergForn = 1;

            // se convergiu, obtem novos valores de perdas e energia fornecida
            if (_fluxoMensal._resFluxoMensal._convergiuBool)
            {
                novaPerdas_kWh    = _fluxoMensal._resFluxoMensal.GetPerdasEnergia();
                novaEnergForn_kWh = _fluxoMensal._resFluxoMensal.GetEnergia();

                // variacao da energia fornecida nao pode ser maior que 5%
                relacaoEnergForn = Math.Abs((novaEnergForn_kWh - _resCasoBase.GetEnergia()) / _resCasoBase.GetEnergia());
            }

            // verifica se isolou cargas
            if (_fluxoMensal.GetNumCargasIsoladas() != _numCargasIsoladas)
            {
                _janela.ExibeMsgDisplayMW("Problema Isolamento de cargas!");
            }

            // se alcancou valor menor de perdas & variacao da energia fornecida nao pode ser maior que 5%
            if (novaPerdas_kWh < _MelhorResultadoPorNA.GetPerdasEnergia() && relacaoEnergForn < 0.05)
            {
                chaveNA.chaveOtimizada = true;

                //  atualiza _MelhorResultadoPorNA
                _MelhorResultadoPorNA = new PFResults(_fluxoMensal._resFluxoMensal);

                // armazena nova perdas na chaveNA para referencia futura
                chaveNA.perda_kWh       = novaPerdas_kWh;
                chaveNA.energiaForn_kWh = _fluxoMensal._resFluxoMensal.GetEnergia();
                chaveNA.perdaPercentual = 100 * chaveNA.perda_kWh / chaveNA.energiaForn_kWh;
                chaveNA.redPerda_kWh    = _resCasoBase.GetPerdasEnergia() - chaveNA.perda_kWh;

                return(true);
            }
            return(false);
        }
コード例 #5
0
        // Fluxo anual
        public void ExecutaAnual(List <string> lstAlimentadoresCemig)
        {
            //Limpa Arquivos
            _paramGerais.DeletaArqResultados();

            //Seta modo anual
            _paramGerais._parGUI._modoAnual = true;

            //Roda fluxo para cada alimentador
            foreach (string alim in lstAlimentadoresCemig)
            {
                // atribui alim
                _paramGerais.SetNomeAlimAtual(alim);

                //Vetor _resultadoFluxo
                List <PFResults> lstResultadoFluxo = new List <PFResults>();

                // para cada mes executa um fluxo mensal
                for (int mes = 1; mes < 13; mes++)
                {
                    // Verifica se foi solicitado o cancelamento.
                    if (_janela._cancelarExecucao)
                    {
                        return;
                    }

                    // set mes
                    _paramGerais._parGUI.SetMes(mes);

                    //cria objeto fluxo diario
                    _fluxoMensal = new MonthlyPowerFlow(_paramGerais, _janela, _oDSS);

                    // se nao carregou alimentador retorna
                    if (_fluxoMensal.CarregaAlimentador())
                    {
                        // Otimiza
                        if (_paramGerais._parGUI._otmPorEnergia)
                        {
                            Otimiza();
                        }
                        else
                        {
                            // Executa Fluxo Mensal
                            _fluxoMensal.ExecutaFluxoMensal();
                        }
                        PFResults resTmp = new PFResults(_fluxoMensal._resFluxoMensal);

                        //Armazena Resultado
                        lstResultadoFluxo.Add(resTmp);
                    }
                    // FIX ME
                    // se nao carregou alimentador, forca mes = 13 para terminar o for
                    else
                    {
                        mes = 13;
                        break;
                    }
                }

                // se convergiu, Calcula resultado Ano
                if (_fluxoMensal._resFluxoMensal._convergiuBool)
                {
                    //Calcula resultado Ano
                    _fluxoMensal._resFluxoMensal.CalculaResAno(lstResultadoFluxo, alim, _paramGerais.GetNomeComp_arquivoResPerdasAnual(), _janela);
                }
            }
        }
コード例 #6
0
        private void AnaliseChavesNAsPvt(string nomeAlim)
        {
            // atribui nomeAlim
            _paramGerais.SetNomeAlimAtual(nomeAlim);

            // Carrega arquivos DSS so MT
            _fluxoSoMT = new DailyFlow(_paramGerais, _janela, _oDSS, null, true);

            // Carrega arquivos DSS
            bool ret = _fluxoSoMT.CarregaAlimentador();

            if (!ret)
            {
                _janela.ExibeMsgDisplayMW("Problema ao executar fluxo só MT!");
                return;
            }

            // executa fluxo snap
            ret = _fluxoSoMT.ExecutaFluxoSnap();

            // se exibeConvergencia
            if (ret)
            {
                // verifica cancelamento usuario
                if (_janela._cancelarExecucao)
                {
                    return;
                }

                // get chaves NAs conjunto/alimentador
                GetChaves();

                // cria objeto grafo, juntamente com as matrizes de incidencia
                _grafo = new FeederGraph(_paramGerais, _janela, _fluxoSoMT._oDSS._DSSText);

                // verifica se extremidades das chaves NAs estao no conjunto escolhido
                // OBS: no momento esta filtrando chaves monofasicas tb
                FiltraLstChavesNAs();

                // TODO
                // Calcula Numero de Loops

                // DEBUG plota chaves
                // plotaChavesNA();

                // TODO criar nova flag interna
                // seta este parametro para true para evitar a recarga dos arquivos texto
                _paramGerais._parGUI._otmPorEnergia = true;
                _paramGerais._parGUI.SetAproximaFluxoMensalPorDU(true);

                // Creates monthly PF obj.
                _fluxoMensal = new MonthlyPowerFlow(_paramGerais, _janela, _oDSS);

                // fluxo mensal que servira de referencia para a otimizacao
                bool ret2 = _fluxoMensal.CalculaFluxoMensalBase();

                if (ret2)
                {
                    // preeenche variavel cargas isoladas
                    _numCargasIsoladas = _fluxoMensal.GetNumCargasIsoladas();

                    // armazena resultado do fluxo em variavel temporaria
                    _resCasoBase = new PFResults(_fluxoMensal._resFluxoMensal);

                    // para cada chave NA, escolhe 1 chave NF
                    BranchExchange();

                    //ajusta numero de FPS, considerando o inicial (so na MT)
                    _fluxoMensal._nFP++;

                    // plota numero de FPs
                    _janela.ExibeMsgDisplayMW("Número de FPs: " + _fluxoMensal._nFP.ToString());

                    // plota pares otimizados
                    PlotaChavesOtimizadas();
                }
            }
        }