module PAREDE_GERAL

! sigla = PAREDE_GERAL_

! objetivo: gerar perfil e malha de canais de refrigeração

! versão original 1.0 (26 Jan 00)

! programador: Carlos Henrique Marchi
! local:       SINMEC/UFSC - Florianópolis - SC

! versão atual    1.0 (26 Jan 00)

! última alteração =   17 Fev 00

!-------------------------------------------------

! RELAÇÃO DAS ROTINAS DESTE MÓDULO:

  ! PAREDE_GERAL_duto_tubeira
  ! PAREDE_GERAL_escreve_binario
  ! PAREDE_GERAL_escreve_texto
  ! PAREDE_GERAL_executa
  ! PAREDE_GERAL_faces
  ! PAREDE_GERAL_faces_duto
  ! PAREDE_GERAL_globais
  ! PAREDE_GERAL_grafico
  ! PAREDE_GERAL_interpola
  ! PAREDE_GERAL_le_dados
  ! PAREDE_GERAL_le_inicio
  ! PAREDE_GERAL_le_tubeira
  ! PAREDE_GERAL_nos
  ! PAREDE_GERAL_nos_duto

!-------------------------------------------------

! rotinas onde são lidos ARQUIVOS de dados neste MÓDULO:

  ! PAREDE_GERAL_le_dados
  ! PAREDE_GERAL_le_inicio
  ! PAREDE_GERAL_le_tubeira

!-------------------------------------------------

! rotinas onde são gerados ARQUIVOS neste MÓDULO:

  ! PAREDE_GERAL_escreve_binario
  ! PAREDE_GERAL_executa
  ! PAREDE_GERAL_grafico

!-------------------------------------------------

use ARQUIVO          ! versão 1.2 (19 Jan 00)

use PAREDE_NOMES     !            (26 Jan 00)

use PLOTA            ! versão 1.2 (19 Jan 00)

use PAREDE_CONSTANTE ! versão 1.0 (26 Jan 00)

use PAREDE_DUTO      ! versão 1.0 (17 Fev 00)

! -----------------------------------------------

implicit none

! -----------------------------------------------

contains

! -----------------------------------------------

  subroutine PAREDE_GERAL_duto_tubeira

    ! *** ALOCAÇÃO DE MEMÓRIA ***

    allocate ( xp(n) )

    allocate ( xe(n-1), re(n-1) )

  end subroutine PAREDE_GERAL_duto_tubeira

! -----------------------------------------------

  subroutine PAREDE_GERAL_escreve_binario

    select case ( sai_binario )

       case ( 1 ) ! escreve todos os parâmetros calculados para o programa CANAL

          open ( unit_aux, file = trim(nome_caso)//'.parede.canal.bin', form='unformatted' )

          write ( unit_aux ) n, m

          write ( unit_aux ) xe, xp, re, le, bp, tp, ee, ep, dp, se, sp, sap, sbp

          close ( unit_aux )

    end select

  end subroutine PAREDE_GERAL_escreve_binario

! -----------------------------------------------

  subroutine PAREDE_GERAL_escreve_texto

    real*8 :: lmin, lmax, lmed, dl

    lmed = ( le(n-1) - le(1) ) / ( n - 2 )

    lmin = 1.0d0
    lmax = 0.0d0
    do i = 1, n-2
       dl = le(i+1) - le(i)
       if ( dl < lmin ) lmin = dl
       if ( dl > lmax ) lmax = dl
    end do
    write ( unit_main, 1 ) lmin, lmed, lmax, lmax/lmin
    1 format ( //, t6, 'comprimento dos volumes de controle', /, &
                 1pe26.15,' = mínimo (m)', /, &
                 1pe26.15,' = médio  (m)', /, &
                 1pe26.15,' = máximo (m)', /, &
                 1pe26.15,' = máximo / mínimo' )

    write ( unit_main, 2 ) le(n-1), le(n-1)/xe(n-1), s_aleta, s_base,  &
                           s_canal, s_tubeira,       s_aleta/s_canal,  &
                           s_base/s_canal,           s_tubeira/s_canal
    2 format ( //,1pe26.15,' = l_canal,   comprimento total do escoamento ao longo dos canais (m)', /, &
                  1pe26.15,' = l_canal / comprimento da câmara-tubeira', /, &
                  1pe26.15,' = s_aleta,   área total de troca de calor das aletas (m2)', /, &
                  1pe26.15,' = s_base,    área total de troca de calor na base dos canais (m2)', /, &
                  1pe26.15,' = s_canal,   s_aleta + s_base (m2)', /, &
                  1pe26.15,' = s_tubeira, área total de troca de calor na parede da tubeira (m2)', /, &
                  1pe26.15,' = s_aleta/s_canal', /, &
                  1pe26.15,' = s_base/s_canal', /, &
                  1pe26.15,' = s_tubeira/s_canal' )

    call ARQUIVO_escreve_campo_1D ( unit_main,       & ! unidade de arquivo para escrever
                            w_campos,                & ! freqüência de escrita
                            '*** raio da tubeira *** (faces )                   ', & ! 50 colunas
                            ' ponto',                & !  6 colunas
                            'x (m)                ', & ! 21 colunas
                            'raio (m)             ', & ! 21 colunas
                            1,                       & ! número do ponto inicial
                            n-1,                     & ! número de dados a escrever
                            xe,                      & ! coordenada espacial
                            re                       ) ! variável a escrever

    if ( tipo_parede == 0 ) go to 10

    call ARQUIVO_escreve_campo_1D ( unit_main,       & ! unidade de arquivo para escrever
                            w_campos,                & ! freqüência de escrita
                            '*** espessura entre tubeira e canal *** (faces)    ', & ! 50 colunas
                            ' ponto',                & !  6 colunas
                            'x (m)                ', & ! 21 colunas
                            'espessura (m)        ', & ! 21 colunas
                            1,                       & ! número do ponto inicial
                            n-1,                     & ! número de dados a escrever
                            xe,                      & ! coordenada espacial
                            ee                       ) ! variável a escrever

    call ARQUIVO_escreve_campo_1D ( unit_main,       & ! unidade de arquivo para escrever
                            w_campos,                & ! freqüência de escrita
                            '*** espessura entre tubeira e canal *** (nós)      ', & ! 50 colunas
                            ' ponto',                & !  6 colunas
                            'x (m)                ', & ! 21 colunas
                            'espessura (m)        ', & ! 21 colunas
                            2,                       & ! número do ponto inicial
                            n-1,                     & ! número de dados a escrever
                            xp,                      & ! coordenada espacial
                            ep                       ) ! variável a escrever

    call ARQUIVO_escreve_campo_1D ( unit_main,       & ! unidade de arquivo para escrever
                            w_campos,                & ! freqüência de escrita
                            '*** altura do canal *** (faces)                    ', & ! 50 colunas
                            ' ponto',                & !  6 colunas
                            'x (m)                ', & ! 21 colunas
                            'altura (m)           ', & ! 21 colunas
                            1,                       & ! número do ponto inicial
                            n-1,                     & ! número de dados a escrever
                            xe,                      & ! coordenada espacial
                            be                       ) ! variável a escrever

    call ARQUIVO_escreve_campo_1D ( unit_main,       & ! unidade de arquivo para escrever
                            w_campos,                & ! freqüência de escrita
                            '*** altura do canal *** (nós)                      ', & ! 50 colunas
                            ' ponto',                & !  6 colunas
                            'x (m)                ', & ! 21 colunas
                            'altura (m)           ', & ! 21 colunas
                            2,                       & ! número do ponto inicial
                            n-1,                     & ! número de dados a escrever
                            xp,                      & ! coordenada espacial
                            bp                       ) ! variável a escrever

    call ARQUIVO_escreve_campo_1D ( unit_main,       & ! unidade de arquivo para escrever
                            w_campos,                & ! freqüência de escrita
                            '*** espessura das aletas do canal *** (faces)      ', & ! 50 colunas
                            ' ponto',                & !  6 colunas
                            'x (m)                ', & ! 21 colunas
                            'espessura (m)        ', & ! 21 colunas
                            1,                       & ! número do ponto inicial
                            n-1,                     & ! número de dados a escrever
                            xe,                      & ! coordenada espacial
                            te                       ) ! variável a escrever

    call ARQUIVO_escreve_campo_1D ( unit_main,       & ! unidade de arquivo para escrever
                            w_campos,                & ! freqüência de escrita
                            '*** espessura das aletas do canal *** (nós)        ', & ! 50 colunas
                            ' ponto',                & !  6 colunas
                            'x (m)                ', & ! 21 colunas
                            'espessura (m)        ', & ! 21 colunas
                            2,                       & ! número do ponto inicial
                            n-1,                     & ! número de dados a escrever
                            xp,                      & ! coordenada espacial
                            tp                       ) ! variável a escrever

    call ARQUIVO_escreve_campo_1D ( unit_main,       & ! unidade de arquivo para escrever
                            w_campos,                & ! freqüência de escrita
                            '*** largura média do canal *** (faces)             ', & ! 50 colunas
                            ' ponto',                & !  6 colunas
                            'x (m)                ', & ! 21 colunas
                            'largura (m)          ', & ! 21 colunas
                            1,                       & ! número do ponto inicial
                            n-1,                     & ! número de dados a escrever
                            xe,                      & ! coordenada espacial
                            ae                       ) ! variável a escrever

    call ARQUIVO_escreve_campo_1D ( unit_main,       & ! unidade de arquivo para escrever
                            w_campos,                & ! freqüência de escrita
                            '*** altura / largura média do canal *** (faces)    ', & ! 50 colunas
                            ' ponto',                & !  6 colunas
                            'x (m)                ', & ! 21 colunas
                            'razão                ', & ! 21 colunas
                            1,                       & ! número do ponto inicial
                            n-1,                     & ! número de dados a escrever
                            xe,                      & ! coordenada espacial
                            be/ae                    ) ! variável a escrever

    10 continue

    call ARQUIVO_escreve_campo_1D ( unit_main,       & ! unidade de arquivo para escrever
                            w_campos,                & ! freqüência de escrita
                            '*** comprimento médio do escoamento *** (faces)    ', & ! 50 colunas
                            ' ponto',                & !  6 colunas
                            'x (m)                ', & ! 21 colunas
                            'comprimento (m)      ', & ! 21 colunas
                            1,                       & ! número do ponto inicial
                            n-1,                     & ! número de dados a escrever
                            xe,                      & ! coordenada espacial
                            le                       ) ! variável a escrever

    call ARQUIVO_escreve_campo_1D ( unit_main,       & ! unidade de arquivo para escrever
                            w_campos,                & ! freqüência de escrita
                            '*** diâmetro hidráulico do escoamento *** (faces)  ', & ! 50 colunas
                            ' ponto',                & !  6 colunas
                            'x (m)                ', & ! 21 colunas
                            'diâmetro (m)         ', & ! 21 colunas
                            1,                       & ! número do ponto inicial
                            n-1,                     & ! número de dados a escrever
                            xe,                      & ! coordenada espacial
                            de                       ) ! variável a escrever

    call ARQUIVO_escreve_campo_1D ( unit_main,       & ! unidade de arquivo para escrever
                            w_campos,                & ! freqüência de escrita
                            '*** diâmetro hidráulico do escoamento *** (nós)    ', & ! 50 colunas
                            ' ponto',                & !  6 colunas
                            'x (m)                ', & ! 21 colunas
                            'diâmetro (m)         ', & ! 21 colunas
                            2,                       & ! número do ponto inicial
                            n-1,                     & ! número de dados a escrever
                            xp,                      & ! coordenada espacial
                            dp                       ) ! variável a escrever

    call ARQUIVO_escreve_campo_1D ( unit_main,       & ! unidade de arquivo para escrever
                            w_campos,                & ! freqüência de escrita
                            '*** área da seção transversal do canal *** (faces) ', & ! 50 colunas
                            ' ponto',                & !  6 colunas
                            'x (m)                ', & ! 21 colunas
                            'área (m2)            ', & ! 21 colunas
                            1,                       & ! número do ponto inicial
                            n-1,                     & ! número de dados a escrever
                            xe,                      & ! coordenada espacial
                            se                       ) ! variável a escrever

    call ARQUIVO_escreve_campo_1D ( unit_main,       & ! unidade de arquivo para escrever
                            w_campos,                & ! freqüência de escrita
                            '*** área da seção transversal do canal *** (nós)   ', & ! 50 colunas
                            ' ponto',                & !  6 colunas
                            'x (m)                ', & ! 21 colunas
                            'área (m2)            ', & ! 21 colunas
                            2,                       & ! número do ponto inicial
                            n-1,                     & ! número de dados a escrever
                            xp,                      & ! coordenada espacial
                            sp                       ) ! variável a escrever

    call ARQUIVO_escreve_campo_1D ( unit_main,       & ! unidade de arquivo para escrever
                            w_campos,                & ! freqüência de escrita
                            '*** área molhada das aletas do canal *** (nós)     ', & ! 50 colunas
                            ' ponto',                & !  6 colunas
                            'x (m)                ', & ! 21 colunas
                            'área (m2)            ', & ! 21 colunas
                            2,                       & ! número do ponto inicial
                            n-1,                     & ! número de dados a escrever
                            xp,                      & ! coordenada espacial
                            sap                      ) ! variável a escrever

    call ARQUIVO_escreve_campo_1D ( unit_main,       & ! unidade de arquivo para escrever
                            w_campos,                & ! freqüência de escrita
                            '*** área da base do canal *** (nós)                ', & ! 50 colunas
                            ' ponto',                & !  6 colunas
                            'x (m)                ', & ! 21 colunas
                            'área (m2)            ', & ! 21 colunas
                            2,                       & ! número do ponto inicial
                            n-1,                     & ! número de dados a escrever
                            xp,                      & ! coordenada espacial
                            sbp                      ) ! variável a escrever

  end subroutine PAREDE_GERAL_escreve_texto 

! -----------------------------------------------

  subroutine PAREDE_GERAL_executa

    ! *** LEITURA DE DADOS ***

    ! arquivo de inicialização do programa PAREDE
    call PAREDE_GERAL_le_inicio ( unit_aux, inicio )

    ! dados do módulo ARQUIVO
    call ARQUIVO_le_inicio ( unit_aux, arquivo_nome_inicio_modulo )
    call ARQUIVO_passa_caso ( nome_caso )

    ! dados do módulo PAREDE_GERAL
    if ( lista_parede_geral == 1 ) call ARQUIVO_notepad_abre_dado ( nome_parede_geral )
    if ( le_parede_geral    == 1 ) call PAREDE_GERAL_le_dados ( unit_aux, nome_parede_geral )
    if ( copia_parede_geral == 1 ) call ARQUIVO_copia_arquivo ( nome_parede_geral )

    ! lê dados da parede selecionada

    select case ( tipo_parede )

       case ( 0 ) ! duto circular
          call PAREDE_DUTO_le_inicio ( unit_aux, duto_nome_inicio_modulo )
          call PAREDE_DUTO_passa_dados ( n )
          call PAREDE_GERAL_duto_tubeira
          call PAREDE_DUTO_raio ( xe, xp, re )
          s_tubeira = 0.0d0

       case ( 1 ) ! dados constantes
          call PAREDE_GERAL_le_tubeira
          call PAREDE_CTE_le_inicio ( unit_aux, constante_nome_inicio_modulo )

    end select

    ! *** ALOCAÇÃO DE MEMÓRIA ***

    allocate ( bp(n),   ep(n),   tp(n),   dp(n),   sbp(n),  sap(n),  sp(n)   )

    allocate ( ae(n-1), be(n-1), ee(n-1), te(n-1), le(n-1), de(n-1), se(n-1) )

    ! *** CÁLCULO DOS PARÂMETROS DA PAREDE SELECIONADA ***

    select case ( tipo_parede )

       case ( 0 ) ! duto circular
          call PAREDE_DUTO_calcula ( ee, be, te )
          call PAREDE_GERAL_faces_duto ( n, xe, re, be, ee, te, ae, le, de, se )
          call PAREDE_GERAL_nos_duto ( n, m, xe, xp, re, be, ee, te,  le,  de, &
                                             se, bp, ep, tp, dp, sbp, sap, sp  )

       case ( 1 ) ! dados constantes
          call PAREDE_CTE_calcula ( ee, be, te )
          call PAREDE_GERAL_faces ( n, m, xe, re, be, ee, te, ae, le, de, se )
          call PAREDE_GERAL_nos ( n, m, xe, xp, re, be, ee, te,  le,  de, &
                                        se, bp, ep, tp, dp, sbp, sap, sp  )

    end select

    call PAREDE_GERAL_globais ( n, m, sbp, sap, s_aleta, s_base, s_canal )

    ! *** GERAÇÃO DOS ARQUIVOS DE SAÍDA ***

    call PAREDE_GERAL_escreve_binario

    if ( w_lista == 1 ) then
   
       call ARQUIVO_cria_arquivo ( unit_main, trim(nome_caso)//'.parede.txt' )

       write ( unit_main, 1 ) titulo
       1 format ( /, t6, a100, // )

       call ARQUIVO_escreve_data_hora ( unit_main )

       call PAREDE_GERAL_escreve_texto

       close ( unit_main )

       if ( lista_caso == 1 ) &
          call ARQUIVO_notepad_abre_saida ( unit_aux, trim(nome_caso)//'.parede.txt' )

    end if

    if ( w_grafico /= 0 .and. tipo_parede /= 0 ) call PAREDE_GERAL_grafico

  end subroutine PAREDE_GERAL_executa

! -----------------------------------------------

  subroutine PAREDE_GERAL_faces ( n, m, xe, re, be, ee, te, ae, le, de, se )

    integer,intent(in) :: n ! número total de volumes de controle + 2
    integer,intent(in) :: m ! número de canais em torno da tubeira

    real*8,dimension(:),intent(in)  :: xe ! coordenada espacial (m)
    real*8,dimension(:),intent(in)  :: re ! raio da tubeira (m)
    real*8,dimension(:),intent(in)  :: be ! altura do canal (m)
    real*8,dimension(:),intent(in)  :: ee ! espessura entre tubeira e canal (m)
    real*8,dimension(:),intent(in)  :: te ! espessura das aletas do canal (m)

    real*8,dimension(:),intent(out) :: ae ! largura média do canal (m)
    real*8,dimension(:),intent(out) :: le ! comprimento médio do escoamento no canal (m)
    real*8,dimension(:),intent(out) :: de ! diâmetro hidráulico da seção transversal do canal (m)
    real*8,dimension(:),intent(out) :: se ! área da seção transversal do canal (m2)

    real*8 :: pi ! constante matemática
    real*8 :: dx, dy, dl ! auxiliares

    pi = dacos(-1.0d0)

    if ( m == 1 ) then
       ae = pi * ( ((re+ee+be)**2) - ((re+ee)**2) ) / be
    else
       ae = pi * ( ((re+ee+be)**2) - ((re+ee)**2) ) / (be*m) - te
    end if

    se = ae * be

    de = 2.0d0 * ae * be / ( ae + be )

    le(1) = xe(1)
    do i = 2, n-1
       dx = xe(i) - xe(i-1)
       dy = re(i-1) + ee(i-1) + be(i-1)/2 - re(i) - ee(i) - be(i)/2
       dl = dsqrt ( (dx**2) + (dy**2) )
       le(i) = le(i-1) + dl
    end do

  end subroutine PAREDE_GERAL_faces

!-------------------------------------------------

  subroutine PAREDE_GERAL_faces_duto ( n, xe, re, be, ee, te, ae, le, de, se )

    integer,intent(in) :: n ! número total de volumes de controle + 2

    real*8,dimension(:),intent(in)  :: xe ! coordenada espacial (m)
    real*8,dimension(:),intent(in)  :: re ! raio da tubeira (m)
    real*8,dimension(:),intent(in)  :: be ! altura do canal (m)
    real*8,dimension(:),intent(in)  :: ee ! espessura entre tubeira e canal (m)
    real*8,dimension(:),intent(in)  :: te ! espessura das aletas do canal (m)

    real*8,dimension(:),intent(out) :: ae ! largura média do canal (m)
    real*8,dimension(:),intent(out) :: le ! comprimento médio do escoamento no canal (m)
    real*8,dimension(:),intent(out) :: de ! diâmetro hidráulico da seção transversal do canal (m)
    real*8,dimension(:),intent(out) :: se ! área da seção transversal do canal (m2)

    real*8 :: pi ! constante matemática
    real*8 :: dx, dy, dl ! auxiliares

    pi = dacos(-1.0d0)

    ae = 0.0d0

    se = pi * (re**2)

    de = 2.0d0 * re

    le = xe

  end subroutine PAREDE_GERAL_faces_duto

!-------------------------------------------------

  subroutine PAREDE_GERAL_globais ( n, m, sbp, sap, s_aleta, s_base, s_canal )

    integer,intent(in) :: n ! número total de volumes de controle + 2
    integer,intent(in) :: m ! número de canais em torno da tubeira

    real*8,dimension(:),intent(in) :: sbp ! área da base do canal (m2)
    real*8,dimension(:),intent(in) :: sap ! área molhada das aletas do canal (m2)

    real*8,intent(out) :: s_aleta ! área total de troca de calor das aletas (m2)
    real*8,intent(out) :: s_base  ! área total de troca de calor na base dos canais (m2)
    real*8,intent(out) :: s_canal ! área total de troca de calor do lado dos canais (m2)

    s_aleta = 0.0d0
    s_base  = 0.0d0

    do i = 2, n-1
       s_aleta = s_aleta + sap(i)
       s_base  = s_base  + sbp(i)
    end do

    s_aleta = m * s_aleta
    s_base  = m * s_base

    s_canal = s_aleta + s_base

  end subroutine PAREDE_GERAL_globais

!-------------------------------------------------

  subroutine PAREDE_GERAL_grafico

    call PLOTA_copia_Wgnuplot

    ! dados do módulo PLOTA: nomes dos casos a plotar (sem as extensões)
    call PLOTA_le_inicio ( unit_aux, plota_nome_inicio_modulo )

    ! grava altura do canal
    call ARQUIVO_grava_campo_1D ( unit_aux,             & ! unidade de arquivo para escrever
                          trim(nome_caso)//'.parede.altura.dat', & ! nome do arquivo
                          w_grafico,                    & ! freqüência de escrita
                          1,                            & ! número do ponto inicial
                          n-1,                          & ! número de dados a escrever
                          xe,                           & ! dados da coluna 1
                          be                            ) ! dados da coluna 2

    ! grava largura do canal
    call ARQUIVO_grava_campo_1D ( unit_aux,             & ! unidade de arquivo para escrever
                          trim(nome_caso)//'.parede.largura.dat', & ! nome do arquivo
                          w_grafico,                    & ! freqüência de escrita
                          1,                            & ! número do ponto inicial
                          n-1,                          & ! número de dados a escrever
                          xe,                           & ! dados da coluna 1
                          ae                            ) ! dados da coluna 2

    call PLOTA_le_dados_gnu (  unit_aux, 'parede.grafico.ent' )
    call PLOTA_gera_gnu ( unit_aux, trim(nome_caso)//'.parede.grafico.gnu' )
    call PLOTA_executa_Wgnuplot ( unit_aux, trim(nome_caso)//'.parede.grafico.gnu' )
 
  end subroutine PAREDE_GERAL_grafico

! -----------------------------------------------

  subroutine PAREDE_GERAL_interpola ( n, xe, xp, ye, yp )

    integer,intent(in) :: n ! número total de volumes de controle + 2

    real*8,dimension(:),intent(in)  :: xe ! coordenada na face (m)
    real*8,dimension(:),intent(in)  :: xp ! coordenada no nó (m)
    real*8,dimension(:),intent(in)  :: ye ! variável a interpolar (face)

    real*8,dimension(:),intent(out) :: yp ! variável a interpolar (nó)

    real*8 :: fator ! auxiliar

    yp(1) = 0.0d0

    do i = 2, n-1
       fator = ( xp(i) - xe(i-1) ) / ( xe(i) - xe(i-1) )
       yp(i) = ye(i-1) + ( ye(i) - ye(i-1) ) * fator
    end do

    yp(n) = 0.0d0

  end subroutine PAREDE_GERAL_interpola

!-------------------------------------------------

  subroutine PAREDE_GERAL_le_dados ( unit, nome )

    integer,      intent(in) :: unit ! unidade do arquivo
    character*(*),intent(in) :: nome ! nome do arquivo

    open ( unit, file = trim(nome) )

    read ( unit, * ) titulo
    read ( unit, * ) tipo_parede
    read ( unit, * ) m
    read ( unit, * ) sai_binario
    read ( unit, * ) w_lista
    read ( unit, * ) lista_caso
    read ( unit, * ) w_campos
    read ( unit, * ) w_grafico
    read ( unit, * ) nome_tubeira

    close ( unit )

  end subroutine PAREDE_GERAL_le_dados

!-------------------------------------------------

  subroutine PAREDE_GERAL_le_inicio ( unit, nome )

    integer,      intent(in) :: unit ! unidade do arquivo
    character*(*),intent(in) :: nome ! nome do arquivo de dados de configuração do programa

    open ( unit, file = trim(nome) )

    read ( unit, * ) nome_parede_geral 
    read ( unit, * ) lista_parede_geral
    read ( unit, * ) le_parede_geral
    read ( unit, * ) copia_parede_geral

    read ( unit, * ) arquivo_nome_inicio_modulo  
    read ( unit, * ) plota_nome_inicio_modulo
    read ( unit, * ) constante_nome_inicio_modulo
    read ( unit, * ) duto_nome_inicio_modulo

    close ( unit )

  end subroutine PAREDE_GERAL_le_inicio

! -----------------------------------------------

  subroutine PAREDE_GERAL_le_tubeira

    open ( unit_aux, file = trim(nome_tubeira), form = 'unformatted' )

    read ( unit_aux ) n, s_tubeira

    ! *** ALOCAÇÃO DE MEMÓRIA ***
    allocate ( xp(n) )
    allocate ( xe(n-1), re(n-1) )

    read ( unit_aux ) xe, xp, re

    close ( unit_aux )

  end subroutine PAREDE_GERAL_le_tubeira

! -----------------------------------------------

  subroutine PAREDE_GERAL_nos ( n, m, xe, xp, re, be, ee, te,  le,  de, &
                                      se, bp, ep, tp, dp, sbp, sap, sp  )

    integer,intent(in) :: n ! número total de volumes de controle + 2
    integer,intent(in) :: m ! número de canais em torno da tubeira

    real*8,dimension(:),intent(in)  :: xe  ! coordenada espacial (m)
    real*8,dimension(:),intent(in)  :: xp  ! coordenada espacial (m)
    real*8,dimension(:),intent(in)  :: re  ! raio da tubeira (m)
    real*8,dimension(:),intent(in)  :: be  ! altura do canal (m)
    real*8,dimension(:),intent(in)  :: ee  ! espessura entre tubeira e canal (m)
    real*8,dimension(:),intent(in)  :: te  ! espessura das aletas do canal (m)
    real*8,dimension(:),intent(in)  :: le  ! comprimento médio do escoamento no canal (m)
    real*8,dimension(:),intent(in)  :: de  ! diâmetro hidráulico da seção transversal do canal (m)
    real*8,dimension(:),intent(in)  :: se  ! área da seção transversal do canal (m2)

    real*8,dimension(:),intent(out) :: bp  ! altura do canal (m)
    real*8,dimension(:),intent(out) :: ep  ! espessura entre tubeira e canal (m)
    real*8,dimension(:),intent(out) :: tp  ! espessura das aletas do canal (m)
    real*8,dimension(:),intent(out) :: dp  ! diâmetro hidráulico da seção transversal do canal (m)
    real*8,dimension(:),intent(out) :: sbp ! área da base do canal (m2)
    real*8,dimension(:),intent(out) :: sap ! área molhada das aletas do canal (m2)
    real*8,dimension(:),intent(out) :: sp  ! área da seção transversal do canal (m2)

    real*8 :: pi ! constante matemática
    real*8 :: dx, dy, dl, perim ! auxiliares

    pi = dacos(-1.0d0)

    call PAREDE_GERAL_interpola ( n, xe, xp, te, tp )
    tp(1) = tp(2)
    tp(n) = tp(n-1)

    call PAREDE_GERAL_interpola ( n, xe, xp, be, bp )
    bp(1) = bp(2)
    bp(n) = bp(n-1)

    call PAREDE_GERAL_interpola ( n, xe, xp, ee, ep )
    ep(1) = ep(2)
    ep(n) = ep(n-1)

    call PAREDE_GERAL_interpola ( n, xe, xp, de, dp )
    dp(1) = dp(2)
    dp(n) = dp(n-1)

    call PAREDE_GERAL_interpola ( n, xe, xp, se, sp )
    sp(1) = sp(2)
    sp(n) = sp(n-1)

    do i = 2, n-1
       sap(i) = ( be(i-1) + be(i) ) * ( le(i) - le(i-1) )
    end do
    sap(1) = sap(2)
    sap(n) = sap(n-1)
    if ( m == 1 ) sap = 0.0d0

    if ( m == 1 ) then
       do i = 2, n-1
          perim = pi * ( re(i-1) + ee(i-1) + re(i) + ee(i) )
          dx = xe(i) - xe(i-1)
          dy = re(i-1) + ee(i-1) - re(i) - ee(i)
          dl = dsqrt ( (dx**2) + (dy**2) )
          sbp(i) = perim * dl
       end do
    else
       do i = 2, n-1
          perim = pi * ( re(i-1) + ee(i-1) + re(i) + ee(i) ) / m - tp(i)
          dx = xe(i) - xe(i-1)
          dy = re(i-1) + ee(i-1) - re(i) - ee(i)
          dl = dsqrt ( (dx**2) + (dy**2) )
          sbp(i) = perim * dl
       end do
    end if
    sbp(1) = sbp(2)
    sbp(n) = sbp(n-1)

  end subroutine PAREDE_GERAL_nos

!-------------------------------------------------

  subroutine PAREDE_GERAL_nos_duto ( n, m, xe, xp, re, be, ee, te,  le,  de, &
                                           se, bp, ep, tp, dp, sbp, sap, sp  )

    integer,intent(in) :: n ! número total de volumes de controle + 2
    integer,intent(in) :: m ! número de canais em torno da tubeira

    real*8,dimension(:),intent(in)  :: xe  ! coordenada espacial (m)
    real*8,dimension(:),intent(in)  :: xp  ! coordenada espacial (m)
    real*8,dimension(:),intent(in)  :: re  ! raio da tubeira (m)
    real*8,dimension(:),intent(in)  :: be  ! altura do canal (m)
    real*8,dimension(:),intent(in)  :: ee  ! espessura entre tubeira e canal (m)
    real*8,dimension(:),intent(in)  :: te  ! espessura das aletas do canal (m)
    real*8,dimension(:),intent(in)  :: le  ! comprimento médio do escoamento no canal (m)
    real*8,dimension(:),intent(in)  :: de  ! diâmetro hidráulico da seção transversal do canal (m)
    real*8,dimension(:),intent(in)  :: se  ! área da seção transversal do canal (m2)

    real*8,dimension(:),intent(out) :: bp  ! altura do canal (m)
    real*8,dimension(:),intent(out) :: ep  ! espessura entre tubeira e canal (m)
    real*8,dimension(:),intent(out) :: tp  ! espessura das aletas do canal (m)
    real*8,dimension(:),intent(out) :: dp  ! diâmetro hidráulico da seção transversal do canal (m)
    real*8,dimension(:),intent(out) :: sbp ! área da base do canal (m2)
    real*8,dimension(:),intent(out) :: sap ! área molhada das aletas do canal (m2)
    real*8,dimension(:),intent(out) :: sp  ! área da seção transversal do canal (m2)

    real*8 :: pi ! constante matemática
    real*8 :: dx, dy, dl, perim ! auxiliares

    pi = dacos(-1.0d0)

    tp(1:n-1) = te
    tp(n) = tp(n-1)

    bp(1:n-1) = be
    bp(n) = bp(n-1)

    ep(1:n-1) = ee
    ep(n) = ep(n-1)

    call PAREDE_GERAL_interpola ( n, xe, xp, de, dp )
    dp(1) = dp(2)
    dp(n) = dp(n-1)

    call PAREDE_GERAL_interpola ( n, xe, xp, se, sp )
    sp(1) = sp(2)
    sp(n) = sp(n-1)

    sap = 0.0d0

    do i = 2, n-1
       perim = pi * ( re(i-1) + re(i) )
       dx = xe(i) - xe(i-1)
       dy = re(i-1) - re(i)
       dl = dsqrt ( (dx**2) + (dy**2) )
       sbp(i) = perim * dl
    end do
    sbp(1) = sbp(2)
    sbp(n) = sbp(n-1)

  end subroutine PAREDE_GERAL_nos_duto

!-------------------------------------------------

end module PAREDE_GERAL
