module paredes

! Objetivos: gerar a geometria para os estudos de transferência de 
!            calor entre o escoamento reativo e o sistema de refrigeração
!            adotado (radiativo ou regenerativo)
! Versão atual: 17 Jun 2009
!
! Lista de subrotinas inclusas:
!   arquivo_escreve_campo1D
!   arquivo_escreve_data_hora
!   arquivo_grava_campo_1D
!   arquivo_passa_data
!   arquivo_passa_hora
!   parede_geral
!   parede_geral_escreve_binario
!   parede_geral_escreve_binario_rad
!   parede_geral_escreve_texto
!   parede_geral_escreve_texto_rad
!   parede_geral_faces
!   parede_geral_globais
!   parede_geral_globais_rad
!   parede_geral_grafico
!   parede_geral_interpola
!   parede_geral_nos
!   parede_geral_nos_rad
!   parede_le_dados_gerais
!   parede_le_dados_radiativo
!   parede_le_dados_regenerativo
!   parede_radiativo
!   parede_regenerativo
!   plota_gera_gnu
!   plota_le_dados_gnu
!   plota_le_inicio
!   tubeira_area_parede


use dados
use portlib

implicit none

! *** variáveis de refrigeração ***
integer ::  tipo_ref  ! tipo de refrigeração adotada: 1 - radiativa; 2 - regenerativa
real*8  ::  epsilon   ! emissividade térmica parede-ambiente (adim.)
real*8  ::  sigma      ! constante de Stefan-Boltzmann (W/m2.K4)
real*8  ::  Tamb      ! temperatura do ambiente (K)

! *** variáveis de malha (parede) ***
integer :: n_canais ! número de canais em torno da tubeira
real*8  :: e_cte    ! espessura entre tubeira e canal (ref.regenerativa) ou entre tubeira e ambiente (ref. radiativa) (m)
real*8  :: b_cte    ! altura do canal (m)
real*8  :: t_cte    ! espessura das aletas do canal (m)

! *** saída de dados ***
integer :: sai_binario   ! tipo de arquivo de saída binário com a malha
                         ! 0 = não gera arquivo
                         ! 1 = todos os parâmetros ()
integer :: w_lista       ! 1 = cria listagem do caso; 0=não
integer :: lista_caso    ! lista conteúdo do arquivo do caso

integer :: w_campos  ! freqüência de escrita dos campos na listagem do caso; 0=não escreve
integer :: w_grafico ! freqüência de escrita dos campos para mostrar gráfico da malha; 0=sem gráfico

integer,private :: unit_main = 30
integer,private :: unit_aux  = 35

! *** propriedades geométricas nos nós dos volumes de controle ***
real*8,dimension(:),allocatable :: xp_par  ! coordenada espacial (m)
real*8,dimension(:),allocatable :: rp_par  ! raio da tubeira (m)
real*8,dimension(:),allocatable :: bp_par  ! altura do canal (m)
real*8,dimension(:),allocatable :: ep_par  ! espessura entre tubeira e canal (m)
real*8,dimension(:),allocatable :: tp_par  ! espessura das aletas do canal (m)
real*8,dimension(:),allocatable :: dp_par  ! diâmetro hidráulico da seção transversal do canal (m)
real*8,dimension(:),allocatable :: sbp_par ! área da base do canal (m2)
real*8,dimension(:),allocatable :: sap_par ! área molhada das aletas do canal (m2)
real*8,dimension(:),allocatable :: sp_par  ! área da seção transversal do canal (m2)

! propriedades geométricas na face leste dos volumes de controle
real*8,dimension(:),allocatable :: xe_par ! coordenada espacial (m)
real*8,dimension(:),allocatable :: re_par ! raio da tubeira (m)
real*8,dimension(:),allocatable :: ae_par ! largura média do canal (m)
real*8,dimension(:),allocatable :: be_par ! altura do canal (m)
real*8,dimension(:),allocatable :: ee_par ! espessura entre tubeira e canal (m)
real*8,dimension(:),allocatable :: te_par ! espessura das aletas do canal (m)
real*8,dimension(:),allocatable :: le_par ! comprimento médio do escoamento no canal (m)
real*8,dimension(:),allocatable :: de_par ! diâmetro hidráulico da seção transversal do canal (m)
real*8,dimension(:),allocatable :: se_par ! área da seção transversal do canal (m2)
real*8,dimension(:),allocatable :: sn_par ! área da parede da tubeira (m2)

! propriedades gerais
real*8 :: s_aleta   ! área total de troca de calor das aletas (m2)
real*8 :: s_base    ! área total de troca de calor na base dos canais (m2)
real*8 :: s_canal   ! área total de troca de calor do lado dos canais (m2)
real*8 :: s_tubeira ! área total de troca de calor da parede da tubeira (m2)

! *** variáveis de plotagem ***
character*(100),private :: titulo        ! título do gráfico
integer,private         :: estilo_curvas ! estilo das curvas: 1=linhas; 2=símbolos; 3=linhas com símbolos
integer,private         :: grids         ! 1=mostra linhas auxiliares para facilitar leitura; 0=não
integer,private         :: dia_int       ! 1=inclui data no título do gráfico; 0=não
integer,private         :: hora_int      ! 1=inclui hora no título do gráfico; 0=não
integer,private         :: num_curvas    ! número de curvas a plotar

character*(100),private :: label_x       ! título das abscissas
integer,private         :: escala_x      ! tipo de escala: 1=linear; 2=logarítmica
integer,private         :: auto_x        ! limites da escala: 0=automático; 1=definido
real*8 ,private         :: inicio_x      ! limite mínimo da escala
real*8 ,private         :: fim_x         ! limite máximo da escala

character*(100),private :: label_y       ! título das ordenadas
integer,private         :: escala_y      ! tipo de escala: 1=linear; 2=logarítmica
integer,private         :: auto_y        ! limites da escala: 0=automático; 1=definido
real*8 ,private         :: inicio_y      ! limite mínimo da escala
real*8 ,private         :: fim_y         ! limite máximo da escala

character*(50),dimension(:),allocatable,private :: nome_curva ! nome do arquivo .dat a plotar
character*(50),dimension(:),allocatable,private :: legenda    ! legenda da curva a plotar

character*220,private :: comando ! linha de comando
character*100,private :: arq     ! linha de comando

contains

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

subroutine arquivo_escreve_campo_1D ( unit,   w,      head_0, head_1, head_2, &
                                      head_3, n_ini,  n,      x,      T       )

    integer,intent(in)             :: unit   ! identificador do arquivo
    integer,intent(in)             :: w      ! freqüência de escrita; 0=não escreve
    integer,intent(in)             :: n_ini  ! ponto ou volume inicial de escrita
    character*(*),intent(in)       :: head_0 ! título do campo
    character*(*),intent(in)       :: head_1 ! título da primeira coluna
    character*(*),intent(in)       :: head_2 ! título da segunda coluna
    character*(*),intent(in)       :: head_3 ! título da terceira coluna
    integer,intent(in)             :: n      ! número de dados a escrever
    real*8,intent(in),dimension(:) :: x      ! coordenada espacial
    real*8,intent(in),dimension(:) :: T      ! variável a escrever

    real*8  :: T_min, T_max ! extremos do campo
    real*8  :: x_min, x_max ! coordenadas dos extremos do campo
    integer :: i ! número do dado

!   head_0 = inicia na coluna 1  ; formato A50
!   head_1 = inicia na coluna 1  ; formato A6
!   head_2 = inicia na coluna 11 ; formato A21
!   head_3 = inicia na coluna 36 ; formato A21
!   inteiro: formato I6
!   real   : formato 1pe25.15

    if ( w == 0 ) return

    write(unit,1) head_0, head_1, head_2, head_3 
    1 format(//,t1, a50, &
             //,t1, a6,   t11, a21,   t36, a21, / )
    do i = n_ini, n
       if ( i==n_ini .or. i==n .or. mod(i,w)==0 ) &
          write(unit,2) i, x(i), T(i)
    end do

    2 format(i6,2(1pe25.15))

    T_min = T(n_ini)
    T_max = T(n_ini)

    do i = n_ini, n
       if ( T(i) <= T_min ) then
          T_min = T(i)
          x_min = x(i)
       end if
       if ( T(i) >= T_max ) then
          T_max = T(i)
          x_max = x(i)
       end if
    end do

    write(unit,3) T_min, x_min, T_max, x_max
    3 format(/,1pe25.15,' = mínimo',1pe25.15,' = X (m)',/, &
               1pe25.15,' = máximo',1pe25.15,' = X (m)') 

end subroutine ARQUIVO_escreve_campo_1D

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

subroutine arquivo_escreve_data_hora ( unit )

    integer,intent(in) :: unit ! arquivo
    integer*4    :: var(8)     ! data e hora
    character*2  :: aux1,aux2  ! auxiliares
    character*4  :: aux3       ! auxiliar
    character*8  :: hora       ! horário
    character*12 :: dia        ! data
    character*20 :: vardate,vartime,varzone ! data e hora
    character*50 :: aux		   ! auxiliar

    call date_and_time(vardate,vartime,varzone,var)

    write(aux,*) var(3)
    aux1 = trim(adjustl(aux))
    write(aux,*) var(2)
    aux2 = trim(adjustl(aux))
    write(aux,*) var(1)
    aux3 = trim(adjustl(aux))

    dia = '('//trim(aux1)//'/'//trim(aux2)//'/'//aux3//')'

    write(aux,*) var(5)
    aux1 = trim(adjustl(aux))
    write(aux,*) var(6)
    aux2 = trim(adjustl(aux))
    write(aux,*) var(7)
    aux3 = trim(adjustl(aux))
    
	hora = trim(aux1)//':'//trim(aux2)//':'//aux3

    write(unit,1) dia, hora
    1 format(5x,'Dia = ',a12,5x,'Hora = ',a8)

end subroutine arquivo_escreve_data_hora

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

subroutine arquivo_grava_campo_1D ( unit, nome, w, n_ini, n, x, T )

    integer,intent(in)             :: unit   ! identificador do arquivo
    character*(*),intent(in)       :: nome   ! nome do arquivo
    integer,intent(in)             :: w      ! freqüência de escrita; 0=não escreve
    integer,intent(in)             :: n_ini  ! ponto ou volume inicial de escrita
    integer,intent(in)             :: n      ! número de dados a escrever
    real*8,intent(in),dimension(:) :: x      ! coordenada espacial
    real*8,intent(in),dimension(:) :: T      ! variável a escrever
    integer :: i ! número do dado

    if ( w == 0 ) return

    open (unit, file = nome )

    do i = n_ini, n
       if ( i==n_ini .or. i==n .or. mod(i,w)==0 ) &
          write(unit,1) x(i), T(i)
    end do

    1 format(4(1pe25.15))

    close(unit)
 
end subroutine arquivo_grava_campo_1D

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

subroutine arquivo_passa_data ( dia )

    character*12,intent(out) :: dia ! data
    integer*4    :: var(8)     ! data e hora
    character*2  :: aux1,aux2  ! auxiliares
    character*4  :: aux3       ! auxiliar
    character*20 :: vardate,vartime,varzone ! data e hora
    character*50 :: aux		   ! auxiliar

    call date_and_time(vardate,vartime,varzone,var)

    write(aux,*) var(3)
    aux1 = trim(adjustl(aux))
    write(aux,*) var(2)
    aux2 = trim(adjustl(aux))
    write(aux,*) var(1)
    aux3 = trim(adjustl(aux))

    dia = '('//trim(aux1)//'/'//trim(aux2)//'/'//aux3//')'

end subroutine arquivo_passa_data

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

subroutine arquivo_passa_hora ( hora )

    character*8,intent(out) :: hora ! horário
    integer*4    :: var(8)     ! data e hora
    character*2  :: aux1,aux2  ! auxiliares
    character*4  :: aux3       ! auxiliar
    character*20 :: vardate,vartime,varzone ! data e hora
    character*50 :: aux		   ! auxiliar

    call date_and_time(vardate,vartime,varzone,var)

    write(aux,*) var(5)
    aux1 = trim(adjustl(aux))
    write(aux,*) var(6)
    aux2 = trim(adjustl(aux))
    write(aux,*) var(7)
    aux3 = trim(adjustl(aux))
    
	hora = trim(aux1)//':'//trim(aux2)//':'//aux3

end subroutine arquivo_passa_hora

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

subroutine parede_geral

    call parede_le_dados_gerais

    ! alocação de memória
    allocate ( xp_par(nx), rp_par(nx), xe_par(nx-1), re_par(nx-1) )

    ! inicialização de dados (propriedades geométricas)
    do i = 1, nx-1
        np = nxy-2*nx+i
        xp_par(i) = xp(np)
        xe_par(i) = x(np)
        re_par(i) = raio(np)
        rp_par(i) = y(np)
    end do
    xp_par(nx) = x(nxy-nx-1)
    rp_par(nx) = y(nxy)

    ! geração dos parâmetros de parede de acordo com o tipo de refrigeração
    select case (tipo_ref)
    case (1)
        call parede_radiativo
    case (2)
        call parede_regenerativo
    end select

end subroutine parede_geral

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

subroutine parede_geral_escreve_binario

    select case ( sai_binario )

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

          open (30, file = trim(caso)//'.parede.canal.bin', form='unformatted' )

          write (30) nx, n_canais

          write (30) xe_par, xp_par, re_par, le_par, bp_par, tp_par,  &
                     ee_par, ep_par, dp_par, se_par, sp_par, sap_par, sbp_par

          close (30)

    end select

end subroutine parede_geral_escreve_binario

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

subroutine parede_geral_escreve_binario_rad

    select case ( sai_binario )

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

          open (30, file = trim(caso)//'.parede.rad.bin', form='unformatted' )

          write (30) nx, n_canais

          write (30) xe_par, xp_par, re_par, ee_par, ep_par, sbp_par

          close (30)

    end select

end subroutine parede_geral_escreve_binario_rad

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

subroutine parede_geral_escreve_texto

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

    lmed = ( le_par(nx-1) - le_par(1) ) / ( nx - 2 )

    lmin = 1.0d0
    lmax = 0.0d0
    do i = 1, nx-2
       dl = le_par(i+1) - le_par(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_par(nx-1),   le_par(nx-1)/xe_par(nx-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
                            nx-1,                    & ! número de dados a escrever
                            xe_par,                  & ! coordenada espacial
                            re_par                   ) ! 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 *** (faces)    ', & ! 50 colunas
                            ' ponto',                & !  6 colunas
                            'x (m)                ', & ! 21 colunas
                            'espessura (m)        ', & ! 21 colunas
                            1,                       & ! número do ponto inicial
                            nx-1,                    & ! número de dados a escrever
                            xe_par,                  & ! coordenada espacial
                            ee_par                   ) ! 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
                            nx-1,                    & ! número de dados a escrever
                            xp_par,                  & ! coordenada espacial
                            ep_par                   ) ! 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
                            nx-1,                    & ! número de dados a escrever
                            xe_par,                  & ! coordenada espacial
                            be_par                   ) ! 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
                            nx-1,                    & ! número de dados a escrever
                            xp_par,                  & ! coordenada espacial
                            bp_par                   ) ! 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
                            nx-1,                    & ! número de dados a escrever
                            xe_par,                  & ! coordenada espacial
                            te_par                   ) ! 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
                            nx-1,                    & ! número de dados a escrever
                            xp_par,                  & ! coordenada espacial
                            tp_par                   ) ! 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
                            nx-1,                    & ! número de dados a escrever
                            xe_par,                  & ! coordenada espacial
                            ae_par                   ) ! 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
                            nx-1,                    & ! número de dados a escrever
                            xe_par,                  & ! coordenada espacial
                            be_par/ae_par            ) ! variável a escrever

    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
                            nx-1,                    & ! número de dados a escrever
                            xe_par,                  & ! coordenada espacial
                            le_par                   ) ! 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
                            nx-1,                    & ! número de dados a escrever
                            xe_par,                  & ! coordenada espacial
                            de_par                   ) ! 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
                            nx-1,                    & ! número de dados a escrever
                            xp_par,                  & ! coordenada espacial
                            dp_par                   ) ! 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
                            nx-1,                    & ! número de dados a escrever
                            xe_par,                  & ! coordenada espacial
                            se_par                   ) ! 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
                            nx-1,                    & ! número de dados a escrever
                            xp_par,                  & ! coordenada espacial
                            sp_par                   ) ! 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
                            nx-1,                    & ! número de dados a escrever
                            xp_par,                  & ! coordenada espacial
                            sap_par                  ) ! 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
                            nx-1,                    & ! número de dados a escrever
                            xp_par,                  & ! coordenada espacial
                            sbp_par                  ) ! variável a escrever

end subroutine parede_geral_escreve_texto 
  
!--------------------------------------------------------------------  

subroutine parede_geral_escreve_texto_rad  

    write ( unit_main, 2 ) s_base,  s_tubeira
    2 format ( //,1pe26.15,' = s_base,    área total de troca de calor na base dos canais (m2)', /, &
                  1pe26.15,' = s_tubeira, área total de troca de calor na parede da tubeira (m2)'   )

    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
                            nx-1,                    & ! número de dados a escrever
                            xe_par,                  & ! coordenada espacial
                            re_par                   ) ! variável a escrever

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

    call arquivo_escreve_campo_1D ( unit_main,       & ! unidade de arquivo para escrever
                            w_campos,                & ! freqüência de escrita
                            '*** espessura da parede da tubeira *** (nós)      ', & ! 50 colunas
                            ' ponto',                & !  6 colunas
                            'x (m)                ', & ! 21 colunas
                            'espessura (m)        ', & ! 21 colunas
                            2,                       & ! número do ponto inicial
                            nx-1,                    & ! número de dados a escrever
                            xp_par,                  & ! coordenada espacial
                            ep_par                   ) ! variável a escrever

    call arquivo_escreve_campo_1D ( unit_main,       & ! unidade de arquivo para escrever
                            w_campos,                & ! freqüência de escrita
                            '*** área de transferência de calor por radiação *** (nós)                ', & ! 50 colunas
                            ' ponto',                & !  6 colunas
                            'x (m)                ', & ! 21 colunas
                            'área (m2)            ', & ! 21 colunas
                            2,                       & ! número do ponto inicial
                            nx-1,                    & ! número de dados a escrever
                            xp_par,                  & ! coordenada espacial
                            sbp_par                  ) ! variável a escrever

end subroutine parede_geral_escreve_texto_rad 
  
!--------------------------------------------------------------------    
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_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_globais_rad ( n, sbp, s_base )

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

    real*8,dimension(:),intent(in) :: sbp ! área externa da tubeira (m2)

    real*8,intent(out) :: s_base  ! área total de troca de calor na base dos canais (m2)

    s_base  = 0.0d0

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

  end subroutine parede_geral_globais_rad

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

  subroutine parede_geral_grafico

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

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

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

    call plota_le_dados_gnu (  unit_aux, 'parede.grafico.ent' )
    call plota_gera_gnu ( unit_aux, trim(caso)//'.parede.grafico.gnu' )

    dos = system ('Wgnuplot ' // trim(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_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_rad ( n, xe, xp, re, ee, ep, sbp  )

    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)  :: xp  ! coordenada espacial (m)
    real*8,dimension(:),intent(in)  :: re  ! raio da tubeira (interno) (m)
    real*8,dimension(:),intent(in)  :: ee  ! espessura da parede da tubeira (m)

    real*8,dimension(:),intent(out) :: ep  ! espessura da parede da tubeira  (m)
    real*8,dimension(:),intent(out) :: sbp ! área externa da tubeira (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, ee, ep )
    ep(1) = ep(2)
    ep(n) = ep(n-1)

    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
    sbp(1) = sbp(2)
    sbp(n) = sbp(n-1)

end subroutine parede_geral_nos_rad

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

subroutine parede_le_dados_gerais

    dos = system('Notepad RHG2D_parede_dados.ent')

    open(30,file = 'RHG2D_parede_dados.ent')

    read(30,*) tipo_ref

    close(30)

end subroutine parede_le_dados_gerais

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

subroutine parede_le_dados_radiativo

    dos = system('Notepad RHG2D_parede_dados_rad.ent')

    open(30,file = 'RHG2D_parede_dados_rad.ent')

    read(30,*) e_cte
    read(30,*) epsilon
    read(30,*) sigma
    read(30,*) Tamb
    read(30,*) sai_binario
    read(30,*) w_lista
    read(30,*) lista_caso    
    read(30,*) w_campos
    read(30,*) w_grafico

    close(30)

end subroutine parede_le_dados_radiativo

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

subroutine parede_le_dados_regenerativo

    dos = system('Notepad RHG2D_parede_dados_reg.ent')

    open(30,file = 'RHG2D_parede_dados_reg.ent')

    read(30,*) n_canais
    read(30,*) e_cte
    read(30,*) b_cte
    read(30,*) t_cte
    read(30,*) sai_binario
    read(30,*) w_lista
    read(30,*) lista_caso    
    read(30,*) w_campos
    read(30,*) w_grafico

    close(30)

end subroutine parede_le_dados_regenerativo

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

subroutine parede_radiativo

    call parede_le_dados_radiativo
    
    ! alocação de variáveis
    allocate ( ep_par(nx),  sbp_par(nx), sn_par(nx) )
    allocate ( ee_par(nx-1) )
    
    !inicialização de variáveis
    ee_par = e_cte
    
    ! área da parede da tubeira
    call tubeira_area_parede ( nx, xe_par, re_par, rp_par, s_tubeira, sn_par )

    ! parâmetros gerais da parede
    call parede_geral_nos_rad ( nx, xe_par, xp_par, re_par, ee_par, ep_par, sbp_par  )

    ! parâmetros globais para a parede
    call parede_geral_globais_rad ( nx, sbp_par, s_base )

    ! arquivos de saída
    call parede_geral_escreve_binario_rad
    
    if ( w_lista == 1 ) then
   
       open( unit_main, file = trim(caso)//'.parede.rad.txt' )

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

       call arquivo_escreve_data_hora ( unit_main )

       call parede_geral_escreve_texto_rad

       close (unit_main)

       if ( lista_caso == 1 ) &
           dos = system ('Notepad ' // trim(caso)//'.parede.rad.txt ')

    end if

end subroutine parede_radiativo

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

subroutine parede_regenerativo
    
    call parede_le_dados_regenerativo
    
    ! alocação de variáveis
    allocate ( bp_par(nx),   ep_par(nx),   tp_par(nx),   dp_par(nx),   sbp_par(nx),  sap_par(nx),  sp_par(nx),  sn_par(nx) )
    allocate ( ae_par(nx-1), be_par(nx-1), ee_par(nx-1), te_par(nx-1), le_par(nx-1), de_par(nx-1), se_par(nx-1) )

    ! inicialização de variáveis
    ee_par = e_cte
    be_par = b_cte
    te_par = t_cte
    
    ! área da parede da tubeira
    call tubeira_area_parede ( nx, xe_par, re_par, rp_par, s_tubeira, sn_par )

    ! parâmetros gerais da parede
    call parede_geral_faces ( nx, n_canais, xe_par, re_par, be_par, ee_par, te_par, ae_par, le_par, de_par, se_par )
    call parede_geral_nos ( nx, n_canais, xe_par, xp_par, re_par, be_par, ee_par, te_par,  le_par,  de_par, &
                                          se_par, bp_par, ep_par, tp_par, dp_par, sbp_par, sap_par, sp_par  )

    ! parâmetros globais para a parede
    call parede_geral_globais ( nx, n_canais, sbp_par, sap_par, s_aleta, s_base, s_canal )

    ! arquivos de saída
    call parede_geral_escreve_binario
    
    if ( w_lista == 1 ) then
   
       open( unit_main, file = trim(caso)//'.parede.txt' )

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

       call arquivo_escreve_data_hora ( unit_main )

       call parede_geral_escreve_texto

       close (unit_main)

       if ( lista_caso == 1 ) &
           dos = system ('Notepad ' // trim(caso)//'.parede.txt ')

    end if

    if ( w_grafico /= 0 ) call parede_geral_grafico

end subroutine parede_regenerativo

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

 subroutine plota_gera_gnu ( unit, nome_arquivo )

    integer,intent(in) :: unit ! identificador do arquivo

    character*(*),intent(in) :: nome_arquivo ! nome do arquivo .gnu a gerar

    character*(12) :: dia        ! data
    character*(8)  :: hora       ! horário
    character*(50) :: legenda_p  ! legenda da curva a plotar
    character*(50) :: aux1, aux2 ! auxiliares

    ! cria arquivo .gnu

    open( unit, file = nome_arquivo )

    ! escreve no arquivo .gnu as funções desejadas

    ! estilo das curvas
    select case ( estilo_curvas )
       case ( 1 ) ! linhas
          write(unit,"('set data style lines')")
       case ( 2 ) ! símbolos
          write(unit,"('set data style points')")
       case ( 3 ) ! linhas com símbolos
          write(unit,"('set data style linespoints')")
    end select

    if ( grids == 1 ) write(unit,"('set grid')") ! mostra a malha 

    comando = ' '

    ! inclui a data no título do gráfico
    if ( dia_int == 1 ) then
       call arquivo_passa_data ( dia )
       comando = trim(comando) // trim(dia)
    end if

    ! inclui a hora no título do gráfico
    if ( hora_int == 1 ) then
       call arquivo_passa_hora ( hora )
       comando = trim(comando) // ' ' // trim(hora)
    end if

    ! escreve título do gráfico
    arq = "set title '" // trim(titulo)
    comando = trim(arq) // ' ' // trim(comando) // "'"
    write(unit,"(a220)") comando

    ! escreve título das abscissas
    arq = "set xlabel '" // trim(label_x) // "'"
    write(unit,"(a100)") arq
   
    if ( escala_x == 2 ) write(unit,"('set logscale x')") ! define escala X logarítmica

    ! define limites da escala das abscissas
    if ( auto_x == 1 ) then
       write(aux1,*) inicio_x
       write(aux2,*) fim_x
       comando = "set xrange[" // trim(adjustl(aux1)) // ":" // trim(adjustl(aux2)) // "]" 
       write(unit,"(a100)") comando
    end if

    ! escreve título das ordenadas
    arq = "set ylabel '" // trim(label_y) // "'"
    write(unit,"(a100)") arq

    if ( escala_y == 2 ) write(unit,"('set logscale y')") ! define escala Y logarítmica

    ! define limites da escala das ordenadas
    if ( auto_y == 1 ) then
       write(aux1,*) inicio_y
       write(aux2,*) fim_y
       comando = "set yrange[" // trim(adjustl(aux1)) // ":" // trim(adjustl(aux2)) // "]" 
       write(unit,"(a100)") comando
    end if

    ! comando para plotar a curva 1
    comando = "plot '" // trim(nome_curva(1)) // "' title '" // trim(legenda(1)) // "'"
    write(unit,"(a220)") comando

    ! comando para plotar curvas 2 a num_curvas
    if ( num_curvas > 1 ) then
       do i = 2, num_curvas
          comando = "replot '" // trim(nome_curva(i)) // "' title '" // trim(legenda(i)) // "'"
          write(unit,"(a220)") comando
       end do
    end if

    close(unit)

  end subroutine plota_gera_gnu

!--------------------------------------------------------------------
subroutine plota_le_dados_gnu ( unit, nome )

    integer,intent(in)       :: unit ! identificador do arquivo
    character*(*),intent(in) :: nome ! nome do arquivo de dados
    
    open ( unit, file = trim(nome) )

    read ( unit, * ) estilo_curvas
    read ( unit, * ) grids
    read ( unit, * ) titulo
    read ( unit, * ) dia_int
    read ( unit, * ) hora_int
    read ( unit, * ) label_x
    read ( unit, * ) escala_x
    read ( unit, * ) auto_x
    read ( unit, * ) inicio_x
    read ( unit, * ) fim_x
    read ( unit, * ) label_y
    read ( unit, * ) escala_y
    read ( unit, * ) auto_y
    read ( unit, * ) inicio_y
    read ( unit, * ) fim_y

    close ( unit )

end subroutine plota_le_dados_gnu

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

subroutine PLOTA_le_inicio 

    integer :: unit = 36
    
    dos = system ( "notepad parede.plota.ent" )     

    open ( unit, file = "parede.plota.ent" )

    read ( unit, * ) num_curvas

    allocate ( nome_curva(num_curvas), legenda(num_curvas) )

    do i = 1, num_curvas
       read ( unit, * ) nome_curva(i), legenda(i)
    end do

    close ( unit )

end subroutine PLOTA_le_inicio

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

subroutine tubeira_area_parede ( n, xe, re, rp, sn_tot, sn )

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

    real*8,dimension(:),intent(in)  :: xe ! coordenada espacial na face leste do volume de controle
    real*8,dimension(:),intent(in)  :: re ! raio na face leste do volume de controle
    real*8,dimension(:),intent(in)  :: rp ! raio no centro do volume de controle

    real*8,intent(out) :: sn_tot ! área total da parede da tubeira (m2)

    real*8,dimension(:),intent(out) :: sn ! área da parede da tubeira

    real*8 :: pi ! constante matemática
    real*8 :: dl ! comprimento da parede do volume
    real*8 :: pw ! perímetro médio da parede do volume 

    pi = dacos(-1.0d0)

    sn_tot = 0.0d0

    do i = 2, n-1
       pw = 2.0d0 * pi * rp(i)
       dl = dsqrt ( (xe(i)-xe(i-1))**2 + (re(i)-re(i-1))**2 )
       sn(i) = pw * dl
       sn_tot = sn_tot + sn(i)
    end do

    sn(1) = sn(2)
    sn(n) = sn(n-1)

end subroutine tubeira_area_parede

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

end module paredes