Beispiel #1
0
    def calcular_potencia(self):

        potencia_fase_a = Fasor(real=0.0, imag=0.0, tipo=Fasor.Potencia)
        potencia_fase_b = Fasor(real=0.0, imag=0.0, tipo=Fasor.Potencia)
        potencia_fase_c = Fasor(real=0.0, imag=0.0, tipo=Fasor.Potencia)
        for no in self.nos_de_carga.values():
            potencia_fase_a = potencia_fase_a + no.potencia_fase_a
            potencia_fase_b = potencia_fase_b + no.potencia_fase_b
            potencia_fase_c = potencia_fase_c + no.potencia_fase_c

        return potencia_fase_a, potencia_fase_b, potencia_fase_c
Beispiel #2
0
    def __init__(
            self,
            nome,
            n1,
            n2,
            #local,
            #config_tr,
            fluxo_fase_a=None,
            fluxo_fase_b=None,
            fluxo_fase_c=None,
            condutor=None,
            comprimento=None,
            resistenciacontato=100):
        assert isinstance(nome, str), 'O parâmetro nome da classe Trecho ' \
                                      'deve ser do tipo str'
        assert isinstance(n1, NoDeCarga) or isinstance(n1, Chave) or isinstance(n1, Gerador), 'O parâmetro n1 da classe Trecho ' \
                                                                                              'deve ser do tipo No de carga ' \
                                                                                              'ou do tipo Chave'
        assert isinstance(n2, NoDeCarga) or isinstance(n2, Chave) or isinstance(n2, Gerador), 'O parâmetro n2 da classe Trecho ' \
                                                                                              'deve ser do tipo No de carga ' \
                                                                                              'ou do tipo Chave'
        super(Trecho, self).__init__(nome)
        self.n1 = n1
        self.n2 = n2
        self.no_montante = None
        self.no_jusante = None
        #self.config_tr = config_tr
        #self.local = local
        self.condutor = condutor
        self.comprimento = comprimento
        self.impedancia_positiva = (self.condutor.rp +
                                    self.condutor.xp * 1j) * self.comprimento
        self.impedancia_zero = (self.condutor.rz +
                                self.condutor.xz * 1j) * self.comprimento
        #self.resistencia_contato = resistenciacontato

        if fluxo_fase_a is None:
            self.fluxo_fase_a = Fasor(real=0.0, imag=0.0, tipo=Fasor.Corrente)
        else:
            self.fluxo_fase_a = fluxo_fase_a

        if fluxo_fase_a is None:
            self.fluxo_fase_b = Fasor(real=0.0, imag=0.0, tipo=Fasor.Corrente)
        else:
            self.fluxo_fase_b = fluxo_fase_b

        if fluxo_fase_a is None:
            self.fluxo_fase_c = Fasor(real=0.0, imag=0.0, tipo=Fasor.Corrente)
        else:
            self.fluxo_fase_c = fluxo_fase_c
Beispiel #3
0
 def __init__(self,
              nome,
              vizinhos,
              potencia=Fasor(real=0.0, imag=0.0, tipo=Fasor.Potencia),
              tensao=Fasor(real=0.0, imag=0.0, tipo=Fasor.Tensao),
              chaves=None):
     super(Barramento, self).__init__(nome,
                                      vizinhos,
                                      potencia=Fasor(real=0.0,
                                                     imag=0.0,
                                                     tipo=Fasor.Potencia),
                                      tensao=Fasor(real=0.0,
                                                   imag=0.0,
                                                   tipo=Fasor.Tensao),
                                      chaves=None)
Beispiel #4
0
    def calcular_potencia(self):

        potencia = Fasor(real=0.0, imag=0.0, tipo=Fasor.Potencia)
        for no in self.nos_de_carga.values():
            potencia = potencia + no.potencia

        return potencia
Beispiel #5
0
    def desativaGD(self):  # adicionado por felipe

        if self.ativo:

            self.ativo = False

            self.potencia_fase_a = Fasor(real=0.0,
                                         imag=0.0,
                                         tipo=Fasor.Potencia)
            self.potencia_fase_a = Fasor(real=0.0,
                                         imag=0.0,
                                         tipo=Fasor.Potencia)
            self.potencia_fase_a = Fasor(real=0.0,
                                         imag=0.0,
                                         tipo=Fasor.Potencia)

        else:

            pass
Beispiel #6
0
    def ativaGD(self):  # adicionado por felipe

        if self.ativo:

            pass

        else:

            self.ativo = True

            self.potencia_fase_a = Fasor(real=self.potencia_nominal.real,
                                         imag=self.potencia_nominal.imag,
                                         tipo=Fasor.Potencia)
            self.potencia_fase_b = Fasor(real=self.potencia_nominal.real,
                                         imag=self.potencia_nominal.imag,
                                         tipo=Fasor.Potencia)
            self.potencia_fase_c = Fasor(real=self.potencia_nominal.real,
                                         imag=self.potencia_nominal.imag,
                                         tipo=Fasor.Potencia)
Beispiel #7
0
    def __init__(
            self,
            nome,
            vizinhos,
            #conexao,
            modelo,
            potencia_fase_a=Fasor(real=0.0, imag=0.0, tipo=Fasor.Potencia),
            potencia_fase_b=Fasor(real=0.0, imag=0.0, tipo=Fasor.Potencia),
            potencia_fase_c=Fasor(real=0.0, imag=0.0, tipo=Fasor.Potencia),
            tensao_fase_a=Fasor(real=0.0, imag=0.0, tipo=Fasor.Tensao),
            tensao_fase_b=Fasor(real=0.0, imag=0.0, tipo=Fasor.Tensao),
            tensao_fase_c=Fasor(real=0.0, imag=0.0, tipo=Fasor.Tensao),
            chaves=None):
        assert isinstance(nome, str), 'O parâmetro nome da classe NoDeCarga' \
                                      ' deve ser do tipo string'
        assert isinstance(vizinhos, list), 'O parâmetro vizinhos da classe' \
                                           ' Barra deve ser do tipo string'

        self.nome = nome
        self.vizinhos = vizinhos
        #self.conexao = conexao
        self.modelo = modelo
        self.potencia_fase_a = potencia_fase_a
        self.potencia_fase_b = potencia_fase_b
        self.potencia_fase_c = potencia_fase_c
        self.potencia_eq_fase_a = Fasor(real=0.0,
                                        imag=0.0,
                                        tipo=Fasor.Potencia)
        self.potencia_eq_fase_b = Fasor(real=0.0,
                                        imag=0.0,
                                        tipo=Fasor.Potencia)
        self.potencia_eq_fase_c = Fasor(real=0.0,
                                        imag=0.0,
                                        tipo=Fasor.Potencia)
        self.tensao_fase_a = tensao_fase_a
        self.tensao_fase_b = tensao_fase_b
        self.tensao_fase_c = tensao_fase_c

        if chaves is not None:
            assert isinstance(chaves, list), 'O parâmetro chaves da classe NoDeCarga' \
                                             ' deve ser do tipo list'
            self.chaves = chaves
        else:
            self.chaves = list()

        self.setor = None
Beispiel #8
0
    def _gerar_nos_de_carga(self):
        # Busca e instanciamento dos objetos do tipo NoDeCarga
        print 'Gerando Nos de Carga...'
        nos_xml = self.ELEMENTOS.find_all('no')
        nos = dict()
        for no_tag in nos_xml:
            elemento_tag = self.TOPO.find_all('elemento',
                                              tipo='no',
                                              nome=no_tag['nome'])[0]
            #if elemento_tag is not None:
            #    elemento_tag.reverse()
            vizinhos = [
                no['nome'] for no in elemento_tag.vizinhos.findChildren('no')
            ]
            vizinhos.reverse()
            chaves_do_no = [
                chave['nome']
                for chave in elemento_tag.chaves.findChildren('chave')
            ]

            potencia_ativa_tag = no_tag.find_all('potencia', tipo='ativa')[0]
            potencia_reativa_tag = no_tag.find_all('potencia',
                                                   tipo='reativa')[0]
            if potencia_ativa_tag['multip'] == 'k':
                potencia_ativa = float(potencia_ativa_tag.text) * 1e3
            elif potencia_ativa_tag['multip'] == 'M':
                potencia_ativa = float(potencia_ativa_tag.text) * 1e6
            else:
                potencia_ativa = float(potencia_ativa_tag.text)

            if potencia_reativa_tag['multip'] == 'k':
                potencia_reativa = float(potencia_reativa_tag.text) * 1e3
            elif potencia_reativa_tag['multip'] == 'M':
                potencia_reativa = float(potencia_reativa_tag.text) * 1e6
            else:
                potencia_reativa = float(potencia_reativa_tag.text)

            print potencia_ativa
            print potencia_reativa
            print chaves_do_no

            nos[no_tag['nome']] = NoDeCarga(nome=no_tag['nome'],
                                            vizinhos=vizinhos,
                                            potencia=Fasor(
                                                real=potencia_ativa,
                                                imag=potencia_reativa,
                                                tipo=Fasor.Potencia),
                                            chaves=chaves_do_no)
            print 'NoDeCarga %s criado.' % nos[no_tag['nome']].nome
        return nos
Beispiel #9
0
    def __init__(self,
                 nome,
                 vizinhos,
                 potencia=Fasor(real=0.0, imag=0.0, tipo=Fasor.Potencia),
                 tensao=Fasor(real=0.0, imag=0.0, tipo=Fasor.Tensao),
                 chaves=None):
        assert isinstance(nome, str), 'O parâmetro nome da classe NoDeCarga' \
                                      ' deve ser do tipo string'
        assert isinstance(vizinhos, list), 'O parâmetro vizinhos da classe' \
                                           ' Barra deve ser do tipo string'

        self.nome = nome
        self.vizinhos = vizinhos
        self.potencia = potencia
        self.potencia_eq = Fasor(real=0.0, imag=0.0, tipo=Fasor.Potencia)
        self.tensao = tensao
        if chaves is not None:
            assert isinstance(chaves, list), 'O parâmetro chaves da classe NoDeCarga' \
                                             ' deve ser do tipo list'
            self.chaves = chaves
        else:
            self.chaves = list()

        self.setor = None
Beispiel #10
0
    def _gerar_transformadores(self):
        # Busca e instanciamento dos objetos do tipo Transformador
        print 'Gerando Transformadores'
        transformadores_xml = self.ELEMENTOS.find_all('transformador')
        transformadores = dict()

        for trafo_tag in transformadores_xml:

            tensao_primario_tag = trafo_tag.find_all('enrolamento',
                                                     tipo='primario')[0].tensao
            if tensao_primario_tag['multip'] == 'k':
                tensao_primario = float(tensao_primario_tag.text) * 1e3
            elif tensao_primario_tag['multip'] == 'M':
                tensao_primario = float(tensao_primario_tag.text) * 1e6
            else:
                tensao_primario = float(tensao_primario_tag.text)

            tensao_secundario_tag = trafo_tag.find_all(
                'enrolamento', tipo='secundario')[0].tensao
            if tensao_secundario_tag['multip'] == 'k':
                tensao_secundario = float(tensao_secundario_tag.text) * 1e3
            elif tensao_secundario_tag['multip'] == 'M':
                tensao_secundario = float(tensao_secundario_tag.text) * 1e6
            else:
                tensao_secundario = float(tensao_secundario_tag.text)

            potencia_tag = trafo_tag.find_all('potencia')[0]
            if potencia_tag['multip'] == 'k':
                potencia = float(potencia_tag.text) * 1e3
            elif potencia_tag['multip'] == 'M':
                potencia = float(potencia_tag.text) * 1e6
            else:
                potencia = float(potencia_tag.text)

            impedancia_tag = trafo_tag.find_all('impedancia',
                                                tipo='seq_pos')[0]
            resistencia_tag = impedancia_tag.resistencia
            reatancia_tag = impedancia_tag.reatancia

            if resistencia_tag['multip'] == 'k':
                resistencia = float(resistencia_tag.text) * 1e3
            elif resistencia_tag['multip'] == 'M':
                resistencia = float(resistencia_tag.text) * 1e6
            else:
                resistencia = float(resistencia_tag.text)

            if reatancia_tag['multip'] == 'k':
                reatancia = float(reatancia_tag.text) * 1e3
            elif resistencia_tag['multip'] == 'M':
                reatancia = float(reatancia_tag.text) * 1e6
            else:
                reatancia = float(reatancia_tag.text)

            transformadores[trafo_tag['nome']] = Transformador(
                nome=trafo_tag['nome'],
                tensao_primario=Fasor(mod=tensao_primario,
                                      ang=0.0,
                                      tipo=Fasor.Tensao),
                tensao_secundario=Fasor(mod=tensao_secundario,
                                        ang=0.0,
                                        tipo=Fasor.Tensao),
                potencia=Fasor(mod=potencia, ang=0.0, tipo=Fasor.Potencia),
                impedancia=Fasor(real=resistencia,
                                 imag=reatancia,
                                 tipo=Fasor.Impedancia))
        return transformadores
Beispiel #11
0
    def __init__(
            self,
            nome,
            ativo,
            vizinhos,
            interface_rede,
            #maquina,
            modelo,
            conexao,
            qmin,
            qmax,
            tensaogerador,
            dvtol,
            x0=0.0j,
            x1=0.0j,
            x2=0.0j,
            xsubt=0.0j,
            xsobrer=0.0,
            potencia_nominal=Fasor(
                real=0.0, imag=0.0,
                tipo=Fasor.Potencia),  # adicionado por felipe
            #potencia_fase_a=Fasor(real=0.0, imag=0.0, tipo=Fasor.Potencia),
            #potencia_fase_b=Fasor(real=0.0, imag=0.0, tipo=Fasor.Potencia),
            #potencia_fase_c=Fasor(real=0.0, imag=0.0, tipo=Fasor.Potencia),
        tensao_fase_a=Fasor(real=0.0, imag=0.0, tipo=Fasor.Tensao),
            tensao_fase_b=Fasor(real=0.0, imag=0.0, tipo=Fasor.Tensao),
            tensao_fase_c=Fasor(real=0.0, imag=0.0, tipo=Fasor.Tensao),
            chaves=None):

        self.nome = nome
        self.ativo = ativo
        self.vizinhos = vizinhos
        #self.potencia_fase_a = potencia_fase_a
        #self.potencia_fase_b = potencia_fase_b
        #self.potencia_fase_c = potencia_fase_c

        self.potencia_nominal = potencia_nominal

        if self.ativo:  # adicionado por felipe

            self.potencia_fase_a = Fasor(real=self.potencia_nominal.real,
                                         imag=self.potencia_nominal.imag,
                                         tipo=Fasor.Potencia)
            self.potencia_fase_b = Fasor(real=self.potencia_nominal.real,
                                         imag=self.potencia_nominal.imag,
                                         tipo=Fasor.Potencia)
            self.potencia_fase_c = Fasor(real=self.potencia_nominal.real,
                                         imag=self.potencia_nominal.imag,
                                         tipo=Fasor.Potencia)

        else:

            self.potencia_fase_a = Fasor(real=0.0,
                                         imag=0.0,
                                         tipo=Fasor.Potencia)
            self.potencia_fase_b = Fasor(real=0.0,
                                         imag=0.0,
                                         tipo=Fasor.Potencia)
            self.potencia_fase_c = Fasor(real=0.0,
                                         imag=0.0,
                                         tipo=Fasor.Potencia)

        self.dvtol = dvtol
        self.potencia_eq_fase_a = Fasor(real=0.0,
                                        imag=0.0,
                                        tipo=Fasor.Potencia)
        self.potencia_eq_fase_b = Fasor(real=0.0,
                                        imag=0.0,
                                        tipo=Fasor.Potencia)
        self.potencia_eq_fase_c = Fasor(real=0.0,
                                        imag=0.0,
                                        tipo=Fasor.Potencia)
        self.tensao_fase_a = tensao_fase_a
        self.tensao_fase_b = tensao_fase_b
        self.tensao_fase_c = tensao_fase_c
        self.interface_rede = interface_rede
        #self.maquina = maquina
        self.modelo = modelo
        self.conexao = conexao
        self.qmin = qmin
        self.qmax = qmax
        self.tensaogerador = tensaogerador
        self.corrente_nominal = 1

        if self.interface_rede == 'INVERSOR':
            self.corrente_curto = 2 * self.corrente_nominal
            self.x1 = 1
        elif self.interface_rede == 'SINCRONO':
            self.xsobrer = xsobrer
            self.xsubt = xsubt
            self.x0 = x0
            self.r0 = self.x0 * (self.xsobrer)**-1
            self.x1 = xsubt
            self.r1 = self.x1 * (self.xsobrer)**-1
            self.x2 = x2
            self.r2 = self.x2 * (self.xsobrer)**-1

        assert isinstance(interface_rede, str), 'O parâmetro interface_rede deve' \
                                             'ser do tipo str'
        # assert isinstance(maquina, str), 'O parâmetro maquina deve' \
        #                                  'ser do tipo str'
        assert isinstance(modelo, str), 'O parâmetro modelo deve' \
                                        'ser do tipo str'
        if chaves is not None:
            assert isinstance(chaves, list), 'O parâmetro chaves da classe NoDeCarga' \
                                             ' deve ser do tipo list'
            self.chaves = chaves
        else:
            self.chaves = list()

        self.setor = None