コード例 #1
0
def exemploKindermann():
    # print estratificacao.curvaEndrenyi(1.15, 401.85, 1726.46)
    # print estratificacao.curvaEdnrenyiBeta(2.6, .138)
    # pa = estratificacao.resistividadeAparente2CamadasMalha(580, 80, 12, 2000, 64.03)
    # print pa

    # Exemplo proposto pelo Kindermann no livro Aterramento Elétrico
    #
    # Projetar uma malha de terra com os seguintes dados pré-definidos:
    # I curto maximo = 3000 A
    # I malha = 1200 A
    # Tempode abertura da proteção para a corrente de defeito é tdefeito = 0.6 seguintes
    # Dimensões da malha,
    # largura 50 m
    # largura  = 40 m
    # profundidade .6 m a partir da base do solo
    # Caracteristicas do solo,
    # ps = pbrita = 3000 ohm*m com uma camada de 20cm colocada na superficie do solo
    # deq  =12 m
    # peq = 580 ohm*m
    # pn+1 = 80 ohm*m

    # determinação de pa, vista pela malha

    print 'Resistividade aparente vista pela malha'

    largura = 40
    comprimento = 50
    area = largura*largura
    dimensao = sqrt(largura**2 + comprimento**2)
    r = area/dimensao

    deq = 12
    pn1 = 80
    peq = 580

    alfa = r/deq
    beta = pn1/peq

    #N = estratificacao.curvaEdnrenyiBeta(alfa, beta)
    #print 'N, ', N
    N = estratificacao.endrenyi1963(beta, alfa, r)
    print 'N, ', N

    #pa = .71*580
    pa = N*580

    print 'largura, ', largura
    print 'comprimento, ', comprimento
    print 'area, ', area
    print 'dimensao, ', dimensao
    print 'r, ', r
    print 'alfa, ', alfa
    print 'beta, ', beta
    print 'pa, ', pa

    print '-'*80

    # cálculando a corrente de defeito

    print 'Calculando a seccao dos condutores'

    iCurtoMaximo = 3000
    iDefeito = .6*iCurtoMaximo
    tDefeito = 0.6

    print 'corrente de curto, ', iCurtoMaximo
    print 'corrente de defeito, ', iDefeito

    scobre = formulaOnderdonkScobre(iDefeito, tDefeito, 30, conexao = 'solda')

    print 'seccao do condutor de cobre, ', scobre

    # calculando a bitola do cabo de ligacao
    # conexão é feita utilizando pressão
    scobreCabo = formulaOnderdonkScobre(iCurtoMaximo, tDefeito, 30, conexao = 'pressao')

    print 's cabo de ligacao, ', scobreCabo

    print '-'*80

    # valores dos potenciais maximos admissiveis

    print 'valores dos potenciais maximos admissiveis'

    pbrita = 3000
    hs = .2
    k = kCoeficienteReflexao(pa, pbrita)

    print 'k, ', k

    cs = potenciais.fatorCorrecaoBrita(hs, pa, pbrita)
    print 'fator de correcao, ', cs

    vToqueMaximo = potenciais.potencialMaximoToqueCS(pbrita, tDefeito, cs)
    print 'V toque maximo, ', vToqueMaximo

    vPassoMaximo = potenciais.potencialMaximoPassoCS(pbrita, tDefeito, cs)
    print'V passo maximo, ', vPassoMaximo

    print '-'*80
コード例 #2
0
def projetaMalhaAterramento(dadosProjeto = projetoMalha, debug = False):
    """Projeto para a malha de aterramento, usando os valores globais
    encontrados no arquivo de projeto da malha. É mostrado os valores
    máximo de tensão de passo e informado se algo saiu errado no projeto
    qualquer iniciativa para mudança não é tomada nessa função.
    """
    global projetoResultado

    ####################################
    # Cálculos da resistência da malha #
    ####################################

    largura = dadosProjeto['mLargura']
    comprimento = dadosProjeto['mComprimento']
    hMalha = dadosProjeto['mProfundidade']
    deq = dadosProjeto['deq']
    pn1 = dadosProjeto['pn1']
    peq = dadosProjeto['peq']

    area = largura*comprimento
    dimensao = sqrt(largura**2 + comprimento**2)
    r = area/dimensao

    alfa = r/deq
    beta = pn1/peq

    ###############################################################
    # CURVA DE ENDRENYI
    # OBS:
    # AINDA NÃO TESTEI PARA DIVERSOS CASOS
    # APENAS PARA UM UNICO CASO ENCONTRADO NO LIVRO DO KINDERMANN
    ###############################################################

    N = estratificacao.endrenyi1963(beta, alfa, r)

    # Resistividade aparente vista pela malha
    pa = peq*N

    if debug:
        print '-'*80
        print 'dimensao, ', dimensao
        print 'raio da malha, ', r
        print 'alfa, ', alfa
        print 'beta, ', beta
        print 'N de Endrenyi, ', N
        print 'resistividade aparente, vista pela malha', pa

    iCurtoMaximo = dadosProjeto['iCurtoMaximo']
    iDefeito = .6*iCurtoMaximo
    tDefeito = dadosProjeto['tDefeito']

    if debug:
        print '-'*80
        print 'corrente de curto, ', iCurtoMaximo
        print 'corrente de defeito, ', iDefeito

    ##########################################
    # calculando a bitola dos cabos da malha #
    ##########################################
    scobre = formulaOnderdonkScobre(iDefeito, tDefeito, 30, conexao = dadosProjeto['condutorMalha'], debug = debug)

    #############################################
    # calculando a bitola dos cabos de ligações #
    #############################################
    scobreCabo = formulaOnderdonkScobre(iCurtoMaximo, tDefeito, 30, conexao = dadosProjeto['condutorLigacoes'], debug = debug)

    if debug:
        print u'secção cabo de ligação, ', scobreCabo
        print u'secção do condutor de cobre, ', scobre

    #psBrita = projetoMalha.get('psBrita')
    psBrita = dadosProjeto['psBrita']
    #hsBrita = projetoMalha.get('hsBrita')
    hsBrita = dadosProjeto['hsBrita']


    k = kCoeficienteReflexao(pa, psBrita)
    cs = potenciais.fatorCorrecaoBrita(hsBrita, pa, psBrita)

    # Potenciais máximos admissiveis
    vToqueMaximo = potenciais.potencialMaximoToqueCS(psBrita, tDefeito, cs)
    vPassoMaximo = potenciais.potencialMaximoPassoCS(psBrita, tDefeito, cs)

    if debug:
        print '-'*80
        print 'k, ', k
        print 'V toque maximo, ', vToqueMaximo
        print 'fator de correcao, ', cs
        print'V passo maximo, ', vPassoMaximo

    # valores iniciais para o espaçamento da malha
    ea = dadosProjeto['ea']
    eb = dadosProjeto['eb']
    [Na, Nb, lCabo] = numeroCondutores(comprimento, largura, ea, eb)

    # Número de condutores é um número inteiro
    Na = round(Na, 0)
    Nb = round(Nb, 0)

    # novo espaçamento entre dois condutores
    ea = espacamentoEntreCondutores(Na, comprimento)
    eb = espacamentoEntreCondutores(Nb, largura)

    ###########################################################################
    # Iniciando todos os cálculos relacionados as tensões de passo, toque     #
    # permitidos para o projeto, levando em consideração corrente de curto    #
    # tempo em que o curto permanecerá no sistema até que a proteção funcione #
    # Equações encontrada no livro do Kindermann                              #
    #                                                                         #
    # OBS: Verificar a sua validade com a IEEE e utilizando Elementos finitos #
    ###########################################################################

    # calculando a resistência da malha
    rMalha = resistenciaMalhaSverak(pa, lCabo, area, hMalha)

    iMalha = dadosProjeto['iMalha']

    # Potencial de toque máximo da malha em relação ao infinito
    # Expressão leva em consideração a maior corrente de curto-circuito
    # monofásica à terra, entre as partes metálicas dos equipamentos e um ponto
    # no infinito.
    # Observação importante, o fato deste valor não atender à condição , não
    # significa que a malha é inadequada.
    vToqueMaximoMalha = rMalha * iMalha

    Kh = correcaoProfundidade(hMalha)

    N = nCondutoresMalha(Na, Nb)

    kii = Kii(N)

    d = diametroCondutor(scobre)

    km = coeficienteMalha(max([ea, eb]), hMalha, d, Kh, N, kii)

    ki = coeficienteIrregularidade(N)

    vMalha = potencialMalha(pa, km, ki, iMalha, lCabo)

    # Estimatica do comprimento mínimo de condutor que a malha deve ter
    # para ficar no limite de segurança
    lMinimo = comprimentoMinimoCondutor(pa, km, ki, iMalha, vToqueMaximo)

    if debug:
        print 'numero de condutores Na, ', Na
        print 'numero de condutores Nb, ', Nb
        print 'comprimento do cabo, ', lCabo
        print 'resistencia da malha, ', rMalha
        print 'v toque maximo da malha, ', vToqueMaximoMalha
        if vToqueMaximoMalha > vToqueMaximo:
            print 'erro projeto: tensao de toque ultrapassa os limites'

        print 'Kh, ', Kh
        print 'Kii, ', kii
        print 'N, ', N
        print 'd, ', d
        print 'km, ', km
        print 'Ki, ', ki

        print 'vMalha, ', vMalha
        if vMalha > vToqueMaximo:
            print 'erro projeto: tensao maxima na malha ultrapassa os limites'

        print 'comprimento minimo condutor, ', lMinimo

    ######################################
    # SALVANDO O RESULTADOS DOS CÁLCULOS #
    ######################################

    projetoResultado['alfa'] = alfa
    projetoResultado['beta'] = beta
    projetoResultado['N'] = N
    projetoResultado['pa'] = pa

    projetoResultado['scobre'] = scobre
    projetoResultado['sCaboLigacao'] = scobreCabo

    projetoResultado['k'] = k
    projetoResultado['cs'] = cs

    projetoResultado['vToqueMaximo'] = vToqueMaximo
    projetoResultado['vPassoMaximo'] = vPassoMaximo

    projetoResultado['ea'] = ea
    projetoResultado['eb'] = eb
    projetoResultado['Na'] = Na
    projetoResultado['Nb'] = Nb
    projetoResultado['lCabo'] = lCabo

    projetoResultado['rMalha'] = rMalha
    projetoResultado['vToqueMaxMalha'] = vToqueMaximoMalha

    projetoResultado['km'] = km
    projetoResultado['kii'] = kii
    projetoResultado['kh'] = Kh
    projetoResultado['ki'] = ki

    projetoResultado['vMalha'] = vMalha

    projetoResultado['lMinimo'] = lMinimo

    return projetoResultado
コード例 #3
0
def projetaMalhaAterramento(dadosProjeto=projetoMalha, debug=False):
    """Projeto para a malha de aterramento, usando os valores globais
    encontrados no arquivo de projeto da malha. É mostrado os valores
    máximo de tensão de passo e informado se algo saiu errado no projeto
    qualquer iniciativa para mudança não é tomada nessa função.
    """
    global projetoResultado

    ####################################
    # Cálculos da resistência da malha #
    ####################################

    largura = dadosProjeto['mLargura']
    comprimento = dadosProjeto['mComprimento']
    hMalha = dadosProjeto['mProfundidade']
    deq = dadosProjeto['deq']
    pn1 = dadosProjeto['pn1']
    peq = dadosProjeto['peq']

    area = largura * comprimento
    dimensao = sqrt(largura ** 2 + comprimento ** 2)
    r = area / dimensao

    alfa = r / deq
    beta = pn1 / peq

    ###############################################################
    # CURVA DE ENDRENYI
    # OBS:
    # AINDA NÃO TESTEI PARA DIVERSOS CASOS
    # APENAS PARA UM UNICO CASO ENCONTRADO NO LIVRO DO KINDERMANN
    ###############################################################

    N = estratificacao.endrenyi1963(beta, alfa, r)

    # Resistividade aparente vista pela malha
    pa = peq * N
    #pa = 388

    if debug:
        print '-' * 80
        print 'dimensao, ', dimensao
        print 'raio da malha, ', r
        print 'alfa, ', alfa
        print 'beta, ', beta
        print 'N de Endrenyi, ', N
        print 'resistividade aparente, vista pela malha', pa

    iCurtoMaximo = dadosProjeto['iCurtoMaximo']
    iDefeito = .6 * iCurtoMaximo
    tDefeito = dadosProjeto['tDefeito']

    if debug:
        print '-' * 80
        print 'corrente de curto, ', iCurtoMaximo
        print 'corrente de defeito, ', iDefeito

    ##########################################
    # calculando a bitola dos cabos da malha #
    ##########################################
    scobre = formulaOnderdonkScobre(iDefeito, tDefeito, 30, conexao=dadosProjeto['condutorMalha'], debug=debug)

    #############################################
    # calculando a bitola dos cabos de ligações #
    #############################################
    scobreCabo = formulaOnderdonkScobre(iCurtoMaximo, tDefeito, 30, conexao=dadosProjeto['condutorLigacoes'],
                                        debug=debug)

    if debug:
        print u'secção cabo de ligação, ', scobreCabo
        print u'secção do condutor de cobre, ', scobre

    #psBrita = projetoMalha.get('psBrita')
    psBrita = dadosProjeto['psBrita']
    #hsBrita = projetoMalha.get('hsBrita')
    hsBrita = dadosProjeto['hsBrita']

    k = kCoeficienteReflexao(pa, psBrita)
    cs = potenciais.fatorCorrecaoBrita(hsBrita, pa, psBrita)

    # Potenciais máximos admissiveis
    vToqueMaximo = potenciais.potencialMaximoToqueCS(psBrita, tDefeito, cs)
    vPassoMaximo = potenciais.potencialMaximoPassoCS(psBrita, tDefeito, cs)

    if debug:
        print '-' * 80
        print 'k, ', k
        print 'V toque maximo, ', vToqueMaximo
        print 'fator de correcao, ', cs
        print'V passo maximo, ', vPassoMaximo

    # valores iniciais para o espaçamento da malha
    ea = dadosProjeto['ea']
    eb = dadosProjeto['eb']

    # O chute inicial gera um numero não inteiro para 
    # os condutores. Algo que não pode existir, entretando
    # pode-se modificar os espaçamentos para um número
    # inteiro ou quebrado, para a correção.
    [Na, Nb, lCabo] = numeroCondutores(comprimento, largura, ea, eb)

    # Número de condutores é um número inteiro
    Na = round(Na, 0)
    Nb = round(Nb, 0)

    # novo espaçamento entre dois condutores
    ea = espacamentoEntreCondutores(Na, comprimento)
    eb = espacamentoEntreCondutores(Nb, largura)

    ###########################################################################
    # Iniciando todos os cálculos relacionados as tensões de passo, toque     #
    # permitidos para o projeto, levando em consideração corrente de curto    #
    # tempo em que o curto permanecerá no sistema até que a proteção funcione #
    # Equações encontrada no livro do Kindermann                              #
    #                                                                         #
    # OBS: Verificar a sua validade com a IEEE e utilizando Elementos finitos #
    ###########################################################################

    # calculando a resistência da malha
    rMalha = resistenciaMalhaSverak(pa, lCabo, area, hMalha)

    print 'resistêncida malha sem correção, ', rMalha

    iMalha = dadosProjeto['iMalha']

    # Potencial de toque máximo da malha em relação ao infinito
    # Expressão leva em consideração a maior corrente de curto-circuito
    # monofásica à terra, entre as partes metálicas dos equipamentos e um ponto
    # no infinito.
    # Observação importante, o fato deste valor não atender à condição , não
    # significa que a malha é inadequada.
    vToqueMaximoMalha = rMalha * iMalha

    Kh = correcaoProfundidade(hMalha)

    N = nCondutoresMalha(Na, Nb)

    kii = Kii(N)

    d = diametroCondutor(scobre)

    km = coeficienteMalha(max([ea, eb]), hMalha, d, Kh, N, kii)

    ki = coeficienteIrregularidade(N)

    # Estimatica do comprimento mínimo de condutor que a malha deve ter
    # para ficar no limite de segurança
    lMinimo = comprimentoMinimoCondutor(pa, km, ki, iMalha, vToqueMaximo)

    # Aqui eu vou fazer uma pequena consideração para o exemplo
    # encontrado no Kindermann, ele utiliza hastes na periferia 
    # para diminuição do potencial de passo
    # lTotal = lCabos + lHastes
    # lHastes = COMPRIMENTO_HASTE * QUANTIDADE_HASTES

    # como a leitura para a haste não foi implementada
    # faço essa pequena gambiarra no codigo, todo cuidado é pouco
    if 1:

        diaHaste = 3 / 4

        # KINDERMANN
        #quanHastes = 73
        #compHaste = 3

        # MAMEDE
        quanHastes = 20
        compHaste = 3

        # dissertação Juliano
        #quanHastes = 33
        #compHaste = 3

        # pequena industria
        #quanHastes = 21
        #compHaste = 6

        #R_ELETRODO_VERTICAL = resistenciaEletrodoVertical(pa, compHaste, diaHaste)
        #KH_MAMEDE = coefReducaoHastesVerticais(0.0543, 5.8917, quanHastes)
        #print 'resistencia eletrodo vertical: ', R_ELETRODO_VERTICAL
        #print 'coeficiente de redução eletrodo vertical: ', KH_MAMEDE
        #rne = KH_MAMEDE*R_ELETRODO_VERTICAL

        # comprimento final dos cabos, segundo Kindermann
        lHastes = compHaste * quanHastes
        lTotal = lCabo + 1.15 * lHastes

        print 'comprimento lHastes : ', lHastes

    else:
        lTotal = lCabo

    kp = coeficienteKp(hMalha, min([ea, eb]), max([Na, Nb]))
    vpsm = potencialPasso(pa, kp, ki, iMalha, lTotal)

    # tambem conhecido como tensão de toque, para situações "normais"
    # não deve ser confudido pela tensão de toque maxima e muito menos
    # com a tensão de toque maximo admissiveis para o malha
    # observação: essa confusão deve sumir, vou modificar o
    # nome das variaveis afim de dimunuir essa confusão.
    vMalha = potencialMalha(pa, km, ki, iMalha, lTotal)

    # correção da resistencia da malha
    rMalha = resistenciaMalhaSverak(pa, lTotal, area, hMalha)
    print 'correcao da resistencia, ', rMalha

    if debug:
        print 'numero de condutores Na, ', Na
        print 'numero de condutores Nb, ', Nb
        print 'comprimento do cabo, ', lCabo
        print 'resistencia da malha, ', rMalha
        print 'v toque maximo da malha, ', vToqueMaximoMalha
        if vToqueMaximoMalha > vToqueMaximo:
            print 'erro projeto: tensao de toque ultrapassa os limites'

        print 'Kh : ', Kh
        print 'Kii: ', kii
        print 'N  : ', N
        print 'd  : ', d
        print 'km : ', km
        print 'Ki : ', ki
        print 'kp : ', kp

        print 'lTotal : ', lTotal

        print 'vpsm : ', vpsm

        print 'vMalha, ', vMalha
        if vMalha > vToqueMaximo:
            print 'erro projeto: tensao maxima na malha ultrapassa os limites'

        print 'comprimento minimo condutor: ', lMinimo

        print 'corrente na malha: ', iMalha

    ######################################
    # SALVANDO O RESULTADOS DOS CÁLCULOS #
    ######################################

    projetoResultado['alfa'] = alfa
    projetoResultado['beta'] = beta
    projetoResultado['N'] = N
    projetoResultado['pa'] = pa

    projetoResultado['scobre'] = scobre
    projetoResultado['sCaboLigacao'] = scobreCabo

    projetoResultado['k'] = k
    projetoResultado['cs'] = cs

    projetoResultado['vToqueMaximo'] = vToqueMaximo
    projetoResultado['vPassoMaximo'] = vPassoMaximo

    projetoResultado['ea'] = ea
    projetoResultado['eb'] = eb
    projetoResultado['Na'] = Na
    projetoResultado['Nb'] = Nb
    projetoResultado['lCabo'] = lCabo

    projetoResultado['rMalha'] = rMalha
    projetoResultado['vToqueMaxMalha'] = vToqueMaximoMalha

    projetoResultado['km'] = km
    projetoResultado['kii'] = kii
    projetoResultado['kh'] = Kh
    projetoResultado['ki'] = ki

    projetoResultado['vMalha'] = vMalha

    projetoResultado['lMinimo'] = lMinimo

    return projetoResultado