quarta-feira, 30 de setembro de 2009

Comparação NCL x GrADS: arquivos ASCII

Olá,

Abaixo mostro outra comparação simples, mas extremamente interessante.

Neste "post" coloco o que talvez seja a maior vantagem do NCL sobre o GrADS, pelo menos ao meu ver: a leitura e plotagem de dados contidos em arquivos ASCII.

Quem usa o GrADS sabe do que estou falando. Para criar um gráfico de dados contidos em um arquivo ASCII é necessário um programa (Fortran ou C) para gerar um arquivo binário dos dados do arquivo ASCII e um arquivo CTL, que possibilita a sua utilização no GrADS.

No NCL, nada disso é necessário, basta abrir o arquivo ASCII diretamente, carregando-o para uma variável (arranjo de qualquer dimensão) e plotá-lo.

Vamos aos exemplos práticos. Tenho um campo de pressão ao nível médio do mar fictício (o programa que gera este campo é apresentado no final deste "post"), armazenado em um arquivo ASCII, chamado campoFicticio.ascii. Primeiro, a tarefa de plotá-lo com o GrADS:

Passo 1: programa Fortran (90 ou 77) para criação do binário.

program campoGrads
implicit none

real, dimension(10,10) :: z

integer :: i,j

open(30, file='campoFicticio.ascii', status='old')
read(30,*) z

close(30)

open(30, file='campoFicticio.bin', &
form='unformatted', access='direct', recl=10*10*8)

write(30,rec=1) z
close(30)

end program campoGrads


Passo 2: o arquivo CTL.

DSET ^campoFicticio.bin
TITLE Campo Ficticio
UNDEF 0.10000E+16
XDEF 10 linear 180 1
YDEF 10 linear 10 1
ZDEF 1 levels 1000

TDEF 1 linear 18z30sep09 1dy

VARS 1

z 0 99 campo ficticio de pressao ao nivel do mar
ENDVARS


Passo 3: script para plotagem do campo.

'open campoFicticio.ctl'
'set grads off'
'display z'
'draw title Campo ficticio - PNMM [hPa] - GrADS'
'printim campoFicticioGRADS.png white x1000 y1000'
'quit'


O Resultado
:



Finalmente, a mesma tarefa, mas executada com o NCL.

Passo 1: leitura do arquivo ASCII e plotagem

load "$NCARG_ROOT/lib/ncarg/nclscripts/csm/gsn_code.ncl"
load "$NCARG_ROOT/lib/ncarg/nclscripts/csm/gsn_csm.ncl"

begin

; lendo arquivo
arquivo = asciiread( "campoFicticio.ascii", -1, "float" )
campo = onedtond( arquivo, (/10,10/) )

; ambiente gráfico
wks = gsn_open_wks( "ps", "campoFicticio" )


; recurso gráfico, apenas para aumentar tamanho da figura
; e colocar o título
res = True

res@gsnMaximize = True

res@tiMainString = "Campo ficticio - PNMM [hPa] - NCL"

; plotando gráfico
plot = gsn_csm_contour( wks, campo, res )


; convertendo para PNG
system("convert -density 300 -geometry 1000x1000"+\
" -trim campoFicticio.ps campoFicticioNCL.png")

; apagando arquivo PS
system("rm campoFicticio.ps")

end


O Resultado:



É isso mesmo, somente um passo para plotar o mesmo gráfico no NCL. E isso serve para qualquer tipo de gráfico. Tens uma série temporal e quer plotar um gráfico XY? Mesmo processo. Basta ler a série temporal e plotá-la.

Abraços,

PS. 1: O campo usado para criar os gráficos acima foi gerado com um programa em Fortran 90, que se encontra abaixo:

program campoFicticio

! sem declaracoes implicitas
implicit none


! variaveis e parametros
integer, parameter :: nx=10, ny=10
real, parameter :: pi = acos(-1.)
real, dimension(ny,nx) :: z
integer :: i,j
real :: dx,dy

! variacao dos eixos x e y
dx = 2*pi/nx
dy = 2*pi/ny

! gerando campo ficticio
do j=0,ny-1
do i=0,nx-1
z(j+1,i+1) = sin(i*dx)*cos(j*dy)*20.+1010.
end do
end do

! escreve campo no arquivo ASCII
open(30, file='campoFicticio.ascii')
write(30,*) z
close(30)

end program campoFicticio

PS. 2: Abaixo as linhas de comando para compilar os programas f90 e rodar os scripts GrADS e NCL

FORTRAN:
$ gfortran -o programaFORTRAN.exe programaFORTRAN.f90

GRADS:
$ grads -bpc scriptGRADS.gs

NCL:
$ ncl scriptNCL.ncl

nas quais programaFORTRAN, scriptGRADS e scriptNCL são os nomes dos arquivos que contêm o programa em Fortran 90, o script do GrADS e o script do NCL, respectivamente, e gfortran é o compilador Fortran 90 que acompanha a maioria das distribuições linux. O símbolo $ indica o prompt da linha de comando do terminal do linux, não sendo necessária a sua digitação.

Comparação NCL e GrADS

Neste "post" quero mostrar uma comparação simples entre dois softwares de visualização e processamento de dados amplamente usados na Meteorologia: o NCAR Command Language (NCL) e o Grid Analysis and Display System (GrADS). Ambos são gratuitos e disponíveis na internet nos endereços http://grads.iges.org/grads/grads.html e http://www.ncl.ucar.edu/, respectivamente.

A escolha entre um e outro é definida, principalmente, pelo gosto pessoal ou pela facilidade em se fazer uma determinada tarefa. Geralmente, o motivo preponderante para a definição do pacote a ser usado é a última.

Durante, praticamente, toda a minha vida acadêmica usei o GrADS, basicamente, porque era o único pacote usado na faculdade e na pós-graduação. Os gráficos gerados para o artigo publicado em 2007 na Monthly Weather Review (http://ams.allenpress.com/perlserv/?request=get-abstract&doi=10.1175%2FMWR3302.1) foram gerados com ele.

Recentemente, descobri, por meio do meu orientador de Iniciação Científica, na UFPel, o NCL. Fiquei impressionado com a qualidade dos gráficos e do ambiente de programação proporcionado por ele. Curioso? Faça um tour pelos exemplos do NCL em http://www.ncl.ucar.edu/Applications/.

Voltando ao assunto deste "post", cuja idéia surgiu quando estava fazendo comparações entre os dois, vou mostrar como se calcula a vorticidade relativa e a sua advecção com ambos pacotes e os seus resultados gráficos.

Para começar, veja abaixo o script em GrADS para este propósito:

* abrindo arquivos
'sdfopen uwnd500hPa.nc'
'sdfopen vwnd500hPa.nc'

* definindo janela de plotagem
'set lat -60 -10'
'set lon 280 330'

* vorticidade relativa
'define zeta = hcurl(uwnd.1,vwnd.2)'

* gradiente meridional de zeta
'define dzetax = cdiff(zeta,x)'
'define dy = cdiff(lat,y)*3.1416/180'

* gradiente zonal de zeta
'define dzetay = cdiff(zeta,y)'
'define dx = cdiff(lon,x)*3.1416/180'

* adveccao de zeta
'define adv = -1*( (uwnd.1*dzetax)/(cos(lat*3.1416/180)*dx) + vwnd.2*dzetay/dy )/6.37e6'

* graficos
* PAINEL 1
'set vpage 0 5.5 4.25 8.5'
'set grads off'
'set gxout shaded'
'display zeta'
'set gxout contour'
'display dzetay/(6.37e6*dy)'
'draw title zeta e dzeta/dy'

* PAINEL 2
'set vpage 5.5 11 4.25 8.5'
'set grads off'
'set gxout shaded'
'display zeta'
'set gxout contour'
'display dzetay/(6.37e6*cos(lat*3.1416/180)*dx)'
'draw title zeta e dzeta/dx'

* PAINEL 3
'set vpage 0 5.5 0 4.25'
'set grads off'
'set gxout shaded'
'display zeta'
'set gxout contour'
'display zeta'
'set gxout vector'
'display uwnd.1;vwnd.2'
'draw title zeta e escoamento'

* PAINEL 4
'set vpage 5.5 11 0 4.25'
'set grads off'
'set gxout shaded'
'display zeta'
'set gxout contour'
'display adv'
'draw title zeta e adv(zeta)'

'printim testeGRADS.png white x1000 y1000'

'quit'



Abaixo está o gráfico gerado por este script:



Agora, vamos ao script do NCL para o mesmo cálculo:

load "$NCARG_ROOT/lib/ncarg/nclscripts/csm/gsn_code.ncl"
load "$NCARG_ROOT/lib/ncarg/nclscripts/csm/gsn_csm.ncl"
load "$NCARG_ROOT/lib/ncarg/nclscripts/csm/contributed.ncl"

begin

; conversão graus -> radianos
g2r = acos(-1.)/180

; abrindo arquivos e carregando variáveis
fu = addfile("uwnd500hPa.nc","r")
fv = addfile("vwnd500hPa.nc","r")
u = short2flt( fu->uwnd(0,0,:,:) )
v = short2flt( fv->vwnd(0,0,:,:) )
lat = fu->lat
dlat = lat(2)-lat(1)
lon = fu->lon
dlon = lon(2)-lon(1)


;------------------ vorticidade relativa
zeta = uv2vr_cfd( u, v, lat, lon, 2 )
copy_VarCoords( u, zeta )

;------------------ gradiente meridional de vorticidade
dzeta_dy = center_finite_diff( zeta(lon|:,lat|:), dlat*g2r*6.37e6, False, 0 )
copy_VarCoords( zeta(lon|:,lat|:), dzeta_dy)

;------------------ gradiente zonal de vorticidade
dzeta_dx = new( dimsizes(u), typeof(u), u@_FillValue )
do k = 0, dimsizes( lat )-1
dx = cos( lat(k)*g2r )*dlon*g2r*6.37e6
dzeta_dx(k,:) = center_finite_diff( zeta(k,:), dx, False, 0 )
end do
copy_VarCoords( zeta, dzeta_dx )

;------------------ adveccao de vorticidade relativa
adv_zeta = -1*( u(lat|:,lon|:)*dzeta_dx(lat|:,lon|:) + \
v(lat|:,lon|:)*dzeta_dy(lat|:,lon|:) ) * 1e10
copy_VarCoords( zeta, adv_zeta )

; janela de plotagem
minlat = -60
maxlat = -10
minlon = 280
maxlon = 330

;------------------ graficos
wks = gsn_open_wks( "ps", "advVorticidadeNCL" )
gsn_define_colormap(wks,"BlWhRe")

; recursos para os gráficos
res = True
res@gsnDraw = False
res@gsnFrame = False
res@gsnMaximize = True
res@gsnAddCyclic = False
res@mpMinLonF = minlon
res@mpMaxLonF = maxlon
res@mpMinLatF = minlat
res@mpMaxLatF = maxlat
res@cnFillOn = True
res@lbLabelBarOn = False
res@gsnSpreadColors = True

res2 = True
res2@gsnAddCyclic = False

; arranjo para gráficos
plot = new( 4, graphic )

; PAINEL 1
res@gsnLeftString = "zeta e dzeta/dy"
plot(0) = gsn_csm_contour_map_overlay( wks, \
zeta({lat|minlat:maxlat},{lon|minlon:maxlon}), \
dzeta_dy({lat|minlat:maxlat},{lon|minlon:maxlon}), \
res, res2 )

; PAINEL 2
res@gsnLeftString = "zeta e dzeta/dx"
plot(1) = gsn_csm_contour_map_overlay( wks, \
zeta({lat|minlat:maxlat},{lon|minlon:maxlon}), \
dzeta_dx({lat|minlat:maxlat},{lon|minlon:maxlon}), \
res, res2 )

; PAINEL 3
res@gsnLeftString = "zeta e escoamento"
res@gsnScalarContour = True ; para plotar contornos e vetores separadamente
plot(2) = gsn_csm_vector_scalar_map( wks, \
u({lat|minlat:maxlat},{lon|minlon:maxlon}), \
v({lat|minlat:maxlat},{lon|minlon:maxlon}), \
zeta({lat|minlat:maxlat},{lon|minlon:maxlon}), \
res )

; PAINEL 4
res@gsnLeftString = "zeta e adv(zeta)"
plot(3) = gsn_csm_contour_map_overlay( wks,
zeta({lat|minlat:maxlat},{lon|minlon:maxlon}), \
adv_zeta({lat|minlat:maxlat},{lon|minlon:maxlon}), \
res, res2 )

; plotando os quatro paineis numa pagina
gsn_panel( wks, plot, (/2,2/), False )

; conversão PS->PNG
system("convert -density 300 -geometry 1000x1000 -trim advVorticidadeNCL.ps advVorticidadeNCL.png")

end


Abaixo está o gráfico resultante:



Os gráficos gerados são aqueles padrões para ambos pacotes. Tentei interfirir o mínimo possível nos mesmo, para que a comparação fosse a mais justa possível.

Os recursos gráficos para os campos plotados com o NCL (definidos por meio dos atributos passados as variáveis res e res2; uso do símbolo "@") são aqueles estritamente necessários para a definição do domínio de plotagem (mp*LonF e mp*LatF), plotagem de campos sobrepostos (gsnFrame e gsnDraw), plotagem de dados não globais (gsnAddCyclic), uso de cores (cnFillOn e gsnSpreadColors) e para plotagem de vetores e contornos (gsnScalarContour). A única linha que muda o gráfico padrão é a

gsn_define_colormap(wks,"BlWhRe")

que escolhe um outro conjunto de cores para campos com preenchimento de cores.

A qualidade superior dos gráficos gerados pelo NCL é facilmente percebida, mas é na parte de programação que vejo a grande vantagem oferecida pelo NCL em comparação com o GrADS. A possibilidade de se lidar com vetores, matrizes e arranjos de variadas dimensões é um forte exemplo desta vantagem.

Ambos pacotes têm funções para o cálculo da vorticidade e para o cálculo de diferenças finitas.

O único ponto no qual o NCL deixa a desejar (ao meu ver) é a perda das informações de coordenadas (os metadados) quando se faz qualquer operação matemática com uma variável, o que não ocorre no GrADS. Suponha que tenho o campo da componente meridional do vento, dada por v[lat, lon], dada em m/s. No GrADS, a operação

vKmH = v*3.6

pode ser plotada diretamente. Já no NCL, preciso copiar as informações das coordenadas espaciais para a nova variável antes de plotá-la

copy_VarCoords( v, vKmH )

Este procedimento foi usado várias vezes no script NCL acima.

O GrADS também tem a facilidade de gerar gráficos em GrADS Metafile (MF), PNG, JPEG e GIF diretamente, enquanto o NCL gera seus gráficos, diretamente, em PS, EPS, EPSI, PDF e NCGM. O GrADS oferece um programa externo (gxps) para a conversão de MF para PS.

A figura PNG foi gerada com o GrADS com a função printim. O arquivo PS do NCL foi convertido para PNG com o programa externo convert, disponibilizado pelo pacote ImageMagick, no linux.

Este é um pequeno exemplo de comparação entre os dois pacotes. Cada um tem as suas vantagens e desvantagens. Não há "o melhor" pacote, mas sim aquele mais adequado às preferências e necessidades pessoais. Faça a sua escolha, compare! Se você usou apenas um deles até hoje, teste o outro!

Em "posts" futuros colocarei mais exemplos de comparações entre os dois pacotes.

Abraços,

INFO: Os dados usados para a geração destes gráficos são da Reanálise 2 do NCEP (http://www.cdc.noaa.gov/data/gridded/data.ncep.reanalysis2.pressure.html). São dados médios do dia 01/01/1979 para as duas componentes do vento: u e v, em 500 hPa.

terça-feira, 22 de setembro de 2009

A técnica de bootstrap

Na meteorologia (e em várias outras áreas) é comum nos depararmos com um conjunto de dados com comportamento distinto das distribuições teóricas, como a Distribuição Normal, por exemplo.

Um problema surge nestes casos: como aferir se a estimação de um parâmetro destes dados é representativa da população, ou seja, que teste de hipótese aplicar nestas situações. A transformação dos dados (mais conhecida como reexpressão dos dados) pode ser uma saída, fazendo com que os dados se aproximem de uma distribuição teórica. Por exemplo, dados de chuva são, geralmente, positivos e altamente concentrados nos valores mais baixos, facilmente descritos por distribuições exponenciais. Entretanto, alguns testes levam em conta, implicitamente, uma "normalidade" nos dados. Pode-se reexpressar estes dados, levando-os a uma distribuição normal, por meio da transformação logarítimica [Wilks 2006, pág. 47].

O analista pode optar, o que normalmente ocorre, por trabalhar com seus dados originais, ou seja, sem transformação alguma. É neste momento que muito cuidado deve ser tomado ao se aferir a representatividade de uma estimação. A aplicação de testes a dados que não seguem a distribuição assumida pelos primeiros pode levar a erros na rejeição ou aceitação da hipótese nula (Erros Tipo I e II, ver Wilks [2006], pág. 133).

Um alternativa aos testes paramétricos (aqueles que levam em consideração algum tipo de distribuição) é o teste não paramétrico. Há vários testes não paramétricos conhecidos, como o teste de Mann-Kendall, usado para identificação de tendências em uma série de dados e o teste de Mann-Whitney, usada para testar se duas amostras foram retiradas de populações com médias iguais, entre vários outros.

Com a maior facilidade tecnológica dos dias de hoje, uma outra abordagem ao teste não paramétrico tem ganhado cada vez mais espaço: os testes de reamostragem, que inclui o Bootstrap. A técnica do Bootstrap realiza uma reamostragem dos dados, com substituição, com o objetivo principal de obter uma distribuição do parâmetro em teste. Para maiores informações a respeito desta técnica, veja o Capítulo 5, Seção 3.4 de Wilks [2006].

O objetivo deste "post" é mostrar como usar o Bootstrap de uma maneira bem simples, usando o R (http://www.r-project.org/), um software gratuito destinado a aplicações estatísticas. Veja o script abaixo:

-------------------- INÍCIO DO SCRIPT ---------------------

# dados de precipitacao (em pol)
p <- c(0.44,1.18,2.69,2.08,3.66,1.72,2.82,0.72,1.46,1.30, 1.35,0.54,2.74,1.13,2.50,1.72,2.27,2.82,1.98,2.44,2.53,2, 1.12,2.13,1.36,4.9,2.94,1.75,1.69,1.88,1.31,1.76,2.17,2.38, 1.16,1.39,1.36,1.03,1.11,1.35,1.44,1.84,1.69,3,1.36,6.37, 4.55, 0.52,0.87,1.51)

teste_sign <- 0.025 # alpha/2, nivel de significancia.
iBoot <- 10000 # numero de reamostragens
p_log <- log(p) # logaritmo da chuva
sd_p_log <- sd(p_log) # desvio padrao dos dados originais
sd_precip_boot <- array(0, c(iBoot)) # desvios padroes reamostras

# loop que faz a reamostragem e calcula o desvio padrao dela
for (i in 1:iBoot) {
dummy <- sample(p_log,replace=T) # reamost. c/ subst.
sd_precip_boot[i] <- sd(dummy) # SD da reamostragem
rm(dummy) # apaga reamostragem
}

# calula quantis em funcao do nivel do teste de significancia
# definido na variavel 'teste_sign'
quantis <- quantile(sd_precip_boot,prob=seq(0.,1.,teste_sign))
nQuantis <- NROW(quantis) # nro de quantis calculados

# plota distribuicao (histograma) dos desvios padroes calculados
# das reamostragens
png("testeBootWilks.png",width=600,height=800) # cria PNG

# desenha histograma com 100 classes
hist(sd_precip_boot, main="Exemplo 5.10 de Wilks [2006]", xlab="desvio padrão", ylab="frequência", breaks=100)
abline(v=quantis[2],lty=2,lwd=2) # lim. inf. interv. confianca
abline(v=quantis[nQuantis-1],lty=2,lwd=2) # lim. sup. interv. confianca abline(v=sd_p_log,lty=1,lwd=2) # desvio padrao dados originais

dev.off() # fecha grafico

---------------- FIM DO SCRIPT ------------------------
As linhas tracejadas dão o Intervalo de Confiança obtido com o Bootstrap dos dados de chuva. Entre estas duas linhas está uma linha cheia, mostrando o valor do desvio padrão do logaritmo das precipitações da amostra original. Resultado: temos 95% de confiança de que o desvio padrão do logaritmo das precipitações está entre 0,41 e 0,65.

Numa pesquisa rápida nas funções disponíveis no R é possível encontrar funções que fazem diretamente o Bootstrap. Todavia, preferi mostrá-lo desta forma por ser mais didático, pois permite um entendimento melhor do processo.

Este método também pode ser aplicado a duas amostras. Mostrarei esta aplicação num "post" posterior.

Abraços,

REFERÊNCIAS:

Wilks (2006), Statistical Methods in the Atmospheric Sciences, Academic Press, 648 pp.

LEITURAS RECOMENDADAS:

LÚCIO, P. S., I. V. LEANDRO e T. P. Paula (2006), Bootstrap aplicado à avaliação de incertezas estatísticas no prognósticos de quantis extremos de precipitação, XIV Congresso Brasileiro de Meteorologia, Florianópolis, SC. Disponível em: http://www.criatividadecoletiva.net/cbm-files/14-eee1d97e2f1534538b995b911f9082b6.pdf



Mapa do Brasil com Estados em destaque

Nos estudos de meteorologia é comum a geração de mapas com campos atmosféricos, que permitem-nos analisar o tempo ou o clima para uma determinada região. Dependendo, é claro, do tipo do campo plotado.

Atualmente, tenho usado o NCAR Command Language (NCL, www.ncl.ucar.edu) para o processamento e plotagem de variáveis e parâmetros meteorológicos. O NCL é uma linguagem interpretada (e gratuita) baseada no NCAR Graphics, um pacote de bibliotecas gráficas para C e Fortran. É uma excelente opção para processar dados atmosféricos, visto a grande oferta de funções e procedimentos, além de possibilitar a criação de gráficos de alta qualidade.

Neste "post", gostaria de compartilhar um script simples, que exemplifica a plotagem de um campo atmosférico sobre a América do Sul. Além do mapa da América do Sul, mostro como plotar o mapa do Brasil e destacar alguns Estados. No exemplo, os Estados da Região Sul do Brasil são destacados.

Chega de blá-blá-blá e vamos ao script:

---------------- INÍCIO DO SCRIPT ----------------------------
load "$NCARG_ROOT/lib/ncarg/nclscripts/csm/gsn_code.ncl"
load "$NCARG_ROOT/lib/ncarg/nclscripts/csm/gsn_csm.ncl"

load "$NCARG_ROOT/lib/ncarg/nclscripts/csm/contributed.ncl"


begin
; abrindo arquivo com dados diários da Reanálise II
dados = addfile( "mslp.2008.nc", "r" )

pnmm = short2flt( dados->mslp )
pnmm = pnmm/100. ; convertendo para hPa
time = dados->time

; escolhendo dia e mes

dia = 23
mes = 07

; obtendo a data no formato UT referenciado

dataUT = ut_inv_calendar( 2008, mes, dia, 0, 0, 0, time@units, 0 )


; area da América do Sul
minLat = -60.
maxLat = 10.

minLon = 270.
maxLon = 330.

;\\\\\\\\\\\\\\\\\ PARTE GRÁFICA DO SCRIPT \\\\\\\\\\\\\\\\\\
; recursos gráficos para o mapa
mapa = True ; habilita recursos gráficos
mapa@gsnMaximize = True ; maximiza gráfico

mapa@gsnAddCyclic = False ; para dados não globais

mapa@mpFillOn = True ; preenchimento de cores do mapa
mapa@mpMonoFillColor = True ; preenchimento com uma cor apenas
mapa@mpFillColor = -1 ; transparente, sem preenchimento de cor

mapa@mpDataSetName = "Earth..4" ; para desenhar
mapa@mpDataBaseVersion = "MediumRes" ; divisao

mapa@mpOutlineOn = True ; politica
mapa@mpOutlineSpecifiers = (/"Brazil:states"/) ; brasileira

; escolhendo estados para sombrear
mapa@mpFillAreaSpecifiers = (/"Brazil:Rio Grande do Sul", \
"Brazil:Santa Catarina", \
"Brazil:Parana" /)
mapa@mpSpecifiedFillColors = new( dimsizes(mapa@mpFillAreaSpecifiers),\
string )
mapa@mpSpecifiedFillColors(:) = "grey" ; cor da sombra no mapa

mapa@mpMaxLonF = maxLon ;
mapa@mpMinLonF = minLon ; area
mapa@mpMaxLatF = maxLat ; de
mapa@mpMinLatF = minLat ; plotagem


; controlando informação dos contornos
mapa@cnInfoLabelString = "Contorno de $CMN$ a $CMX$; intervalo = $CIU$"

; aumentando a espessura dos contornos

mapa@cnLineThicknessF = 3.


; criando ambiente gráfico e definindo a sua saída em PostScript

wks = gsn_open_wks( "ps", "pnmm" )


; nome do campo e unidade física

mapa@gsnLeftString = "PNMM para "+sprinti("%0.2i",dia)+ \

"/"+sprinti("%0.2i",mes)+"/2008"

mapa@gsnRightString = "[hPa]"


; plotando campo de PNMM com os estados da Região Sul do Brasil destacados
plotaMapa = gsn_csm_contour_map_ce( wks, pnmm( {dataUT}, \
{minLat:maxLat}, {minLon:maxLon} ), mapa )

; convertendo gráfico de PS para PNG com ferramenta externa (ImageMagick)
system("convert -geometry 1000x1000 -density 300 -trim pnmm.ps pnmm.png")
system("rm -f pnmm.ps") ; apaga arquivo PS
end

--------------------------- FIM DO SCRIPT -------------------------------

Os dados de PNMM usados foram obtidos da Renálise II do NCEP-DOE (www.cdc.noaa.gov) e são médias diárias para o ano de 2008. A execução deste script resulta no gráfico abaixo (clique na imagem para vẽ-la em tamanho maior).



Algumas observações:

(1) como o Blogger não permite linhas longas, várias linhas do script estão cortadas e continuadas na linha seguinte. Por isso, ao copiar o script e colá-lo num arquivo ASCII, observa as linhas atentamente para que o mesmo possa funcionar corretamente.

(2) é possível escolher o dia e o mês para a plotagem, mas note que a data é convertida para outro formato. Este formato é o Tempo Universal Referenciado ou UT-referenced date, que usa um referencial para a contagem do tempo. Mais informações, veja

Modified Julian Date, em http://tycho.usno.navy.mil/mjd.html
Função ut_inv_calendar do NCL, em http://www.ncl.ucar.edu/Document/Functions/Built-in/ut_inv_calendar.shtml

(3) os dados da Reanálise I e II são armazenados em arquivos netCDF em variáveis do tipo short, que permitem salvar algum espaço em disco, pois ocupa menos espaço que variáveis ponto-flutuante (float). Entretanto, para usá-los deve-se convertê-los para o tipo float (equivalente ao REAL, do Fortran). A função short2flt (disponibilizada pela biblioteca contributed.ncl, carregada no início do script) faz este trabalho, pois usa informações importantes disponibilizadas pelo arquivo netCDF para esta conversão. Maiores detalhes, veja http://www.ncl.ucar.edu/Document/Functions/Contributed/short2flt.shtml.

Note como é simples a escolha do(s) Estado(s) brasileiro(s) a ser(em) enfatizado(s), basta usar o seu nome, sem abreviações, sem complicações. Consulte os exemplos no site no NCL para vislumbrar todas as suas possibilidades.

É isso aí, espero que este exemplo possa ser útil.

Abraços,