Caros amigos,


Temporariamente, o Blog "Sinopticamente falando ..." perdeu as imagens e figuras usadas nos vários textos publicados.

Peço desculpas pelo inconveniente e espero, em breve, deixar tudo como estava antes desse problema.

Independente disso, a maioria dos textos trazem scripts e programas que reproduziam as figuras apresentadas. Portanto, perde-se, temporariamente, a possibilidade de comparação.

Agradeço a atenção e visitas e estou aberto à sugestões, comentários e críticas.

Grande abraço,

Mateus

Controlando eixos no NCL - Parte 2

Olá,

Agora, vamos ver como é possível alterar valores dos eixos de um gráfico no NCL. Para isso, também se usam os recursos para Tick marks.

Quem controla os valores dos eixos são os recursos (para cada um dos eixos) que terminam com Mode, ou seja, determinam o modo de atribuição de valores aos eixos do gráfico. Similarmente aos recursos usados para ligar/desligar eixos, temos:

tmXBMode, tmXTMode, tmYLMode e tmYRMode, que determinam os modos de atribuição de valores aos eixos X inferior, X superior, Y da esquerda e Y da direita, respectivamente.

Esses recursos aceitam três opções: Automatic, Manual ou Explicit. Para cada uma dessas opções, outros recursos devem ser definidos para que possamos alterar apropriadamente os valores dos eixos. Para simplificar a explicação, vamos nos fixar apenas no eixo X inferior, ou seja, em XB.

Definindo (novamente, suponha que temos uma variável lógica opcao, que receberá os recursos):

opcao@tmXBMode = "Automatic"

o NCL determinará os valores do eixo automaticamente. Este é o comportamento padrão. Como vocês já puderam notar, quando plotamos algum gráfico no NCL, ele já atribui valores aos eixos.

Agora, definindo

opcao@tmXBMode = "Manual"

informamos que a atribuição dos valores ao eixo X inferior será feita manualmente. Para isso, precisamos definir mais alguns recursos, que determinarão o valor inicial, o valor final, e o espaçamento entre os valores do eixo:

tmXBTickStartF: informa ao NCL o valor inicial (TickStart) para o eixo X inferior (XB)
tmXBTickEndF: informa ao NCL o valor final (TickEnd) para o eixo X inferior (XB)
tmXBTickSpacingF: informa ao NCL o intervalo entre os valores (TickSpacing) do eixo X inferior (XB)

Notem que ao final destes recursos há um F, que indica que o valor passado ao recurso pode ser real. Quando não há este F no final, deve-se passar um número inteiro, um valor lógico ou uma palavra (string).

Por fim, definindo

opcao@tmXBMode = "Explicit"

informamos que a atribuição dos valores ao eixo X inferior será feita explicitamente. Isto significa que determinaremos a quantidade de valores e quais valores (rótulos) serão atribuídos. Como no caso anterior, devemos usar outros recursos para esta forma de controle:

tmXBValues: informa ao NCL as posições coordenadas do eixo X inferior as quais serão atribuídos os rótulos deste eixo
tmXBLabels: informa ao NCL os rótulos que serão impressos no gráfico, nas posições informadas no recurso anterior.

A estes dois recursos normalmente se atribuem vetores, que indicam as coordenadas e os rótulos a serem impressos, respectivamente.

Vamos a exemplos práticos:

a) tmXBMode definido como Manual

opcao@tmXBMode = "Manual"
opcao@tmXBTickStartF = 1950
opcao@tmXBTickEndF = 2005
opcao@tmXBTickSpacingF = 5

b) tmXBMode definido como Explicit

opcao@tmXBMode = "Explicit"
opcao@tmXBValues = (/1950,1960,1970,1980,1990,2000,2005/)
opcao@tmXBLabels = (/"1950","1960","1970","1980","1990","2000","2005"/)

Notem que os vetores passados a tmXBValues e a tmXBLabels têm o mesmo número de elementos. Se isto não ocorrer, o NCL retorna um erro.

Estes exemplos foram retirados do Exemplo 2 da página dos exemplos do NCL referentes aos Tick Marks (http://www.ncl.ucar.edu/Applications/tickmarks.shtml). Tente executá-lo para entender o funcionamento dos recursos.

Lembrem-se que o apresentado acima vale para qualquer um dos eixos.

Abraços.

Controlando eixos no NCL - Parte 1

Olá,

Neste post vou falar um pouco sobre o controle de eixos em gráficos do NCL. Os recursos usados para alterar os eixos dos gráficos referem-se aos Tick marks (veja alguns exemplos disponíveis na página do NCL: http://www.ncl.ucar.edu/Applications/tickmarks.shtml). Esses recursos começam sempre com tm e os demais caracteres indicam o que eles fazem. Por exemplo, tmYROn retira ou coloca o eixo Y da direita. Vamos desmembrá-lo:

tm: indica que este recurso permite o controle dos eixos
YR: indica que o eixo Y que fica à direita (R) será alterado
On: indica que este recurso serve para colocar ou retirar o eixo, dependendo do valor passado ao recurso.

Vamos aos exemplos. Suponha que temos a variável lógica opcao definida para receber os recursos. Assim,

opcao@tmYROn = False

retira o eixo Y da direita, enquanto que

opcao@tmYROn = True

coloca o eixo Y da direita.

Usando da mesma lógica descrita acima, é possível retirar e colocar qualquer um dos eixos, bastando usar L para escolher o outro eixo Y, T ou B para escolher o eixo X superior ou inferior, respectivamente. É claro, no caso do eixo X, troca-se o Y do recurso por X. Portanto, temos os seguintes recursos para colocar ou retirar os eixos do gráfico:

tmYROn: retira/coloca o eixo Y da direita
tmYLOn: retira/coloca o eixo Y da esquerda
tmXTOn: retira/coloca o eixo X superior
tmXBOn: retira/coloca o eixo X inferior

Como mostrado acima, esses recursos são como chaves, ou seja, desligamos ou ligamos estes eixos usando True (verdadeiro) ou False (falso). O Exemplo 3 da página de exemplos do NCL apresentada acima ilustra o uso destes recursos.

Espero que tenha sido útil.

Makefiles (arquivos make)

O make é um programa geral que constrói destinos a partir de pré-requisitos. O destino pode ser um programa executável, um documento ou uma outra coisa. Os pré-requisitos poderão ser o código Fortran, um arquivo de texto TEX, etc.

Embora você possa escrever scripts do shell simples para executar os comandos do fxx construindo um programa executável, o make é especial pelo fato de conhecer quais destinos precisam ser reconstruídos e quais não precisam.

Por exemplo: digamos que você tem um programa que consiste em três arquivos de origem Fortran. Se você construir o executável usando o comando:

$ gfortran -o teste.exe teste.f90 sub1.f90 sub2.f90

sempre que alterar qualquer um dos arquivos de origem, todos os três serão recompilados, gerando o executável. Se você alterou apenas um arquivo de origem, isto será uma verdadeira perda de tempo (especialmente se o programa em questão for muito maior). O que você deseja fazer de fato é recompilar apenas o arquivo de origem que foi alterado em um arquivo-objeto e ligar todos os arquivos-objeto no programa para formar o executável. O make pode automatizar este processo para você.

O que o make faz

O objetivo básico do make é permitir que você construa um arquivo em pequenas etapas. Se muitos arquivos de origem compuserem o executável final, você poderá alterar um e reconstruir o executável sem ter que recompilar tudo. Para fornecer tal flexibilidade, o make registrará quais arquivos você precisará para fazer a sua construção.

O texto abaixo é um exemplo de arquivo make comum. Denomine-o como makefile ou Makefile e mantenha-o no mesmo diretório dos arquivos de origem.

programa: teste.o sub1.o sub2.o
 gfortran -o teste.exe teste.o sub1.o sub2.o

teste.o: teste.f90
 gfortran -c teste.f90

sub1.o: sub1.f90
 gfortran -c sub1.f90

sub2.o: sub2.f90
 gfortran -c sub2.f90


Este arquivo irá construir um programa denominado teste.exe a partir de três arquivos de origem, teste.f90, sub1.f90 e sub2.f90. Você não está restrito à programação Fortran 90 em um arquivo make.

Quatro entradas aparecem no arquivo. Cada uma contém uma linha de dependência que mostra como um arquivo é construído. Assim, a primeira linha informa que o programa (nome antes dos dois pontos) é construído a partir dos três arquivos-objeto teste.o, sub1.o e sub2.o (os nomes depois dos dois pontos). O que esta linha informa ao make é que ele deverá executar a linha gfortran seguinte sempre que um destes arquivos-objeto for alterado. As linhas que contêm os comandos precisam começar com tabulações (não espaços).

Os arquivos depois dos dois pontos são chamados de dependentes ou de pré-requisitos. Os arquivos objeto serão construídos se eles não existirem ou se algum dos arquivos de origem associado for mais recente.

Como o make saberá se um arquivo é novo? Ele analisará o instante de modificação, que o sistema de arquivos associa a todo arquivo. Você pode ver esta informação executando o comando ls -l. Como a informação de instante de tempo tem uma precisão de um segundo, ele informará precisamente ao make se você editou um arquivo de origem desde a última compilação ou se compilou um arquivo objeto desde a última vez que o executável foi construído.

Numa primeira execução, teremos:

$ make programa
gfortran -c teste.f90
gfortran -c sub1.f90
gfortran -c sub2.f90
gfortran -o teste.exe teste.o sub1.o sub2.o


Se editarmos o sub1.f90 e executarmos de novo o comando make programa, ele irá reconstruir apenas os arquivos necessários, economizando tempo, ou seja,

$ make programa
gfortran -c sub1.f90
gfortran -o teste.exe teste.o sub1.o sub2.o


Não importa a ordem na qual as entradas estão no arquivo makefile. O make descobrirá quais arquivos dependem de quais e executará todos os comandos na ordem correta. Colocar uma entrada primeiro para o programa será conveniente, pois se tornará o arquivo construído por padrão (default). Em outras palavras, digitar make será o mesmo que digitar make programa.

Veja agora este outro exemplo:

programa: teste.o sub1.o sub2.o
 gfortran -o teste.exe teste.o sub1.o sub2.o

teste.o: teste.f90
 gfortran -c teste.f90

sub1.o: sub1.f90
 gfortran -c sub1.f90

sub2.o: sub2.f90
 gfortran -c sub2.f90

clean:
 rm -rf teste.exe teste.o sub1.o sub2.o

install:
 mkdir ./testeProg
 cp teste.exe testeProg


Neste exemplo, duas regras são adicionadas: clean e install. É comum encontrar regras de mesmo nome em códigos fontes de programas em Linux.

Algumas regras da sintaxe

A coisa mais difícil sobre manter os arquivos make, pelo menos se você não tiver experiência com eles, é ter a sintaxe correta. Se você usar espaços onde deveria colocar tabulações ou vice-versa, o seu arquivo make irá paralisar. E as mensagens de erro serão totalmente confusas.

Sempre coloque tabulação no começo de um comando, não espaços. E não use uma tabulação antes de qualquer outra linha.

Você poderá colocar uma cerquilha (#) em qualquer lugar em uma linha para iniciar um comentário. Tudo depois da cerquilha será ignorado.

Se você colocar uma barra invertida no final de uma linha, ela irá prosseguir na próxima linha. Isto funcionará em comandos longos e também em outros tipos de linhas do arquivo make.

Seção Mãos na Massa

Abaixo estão programas simples em Fortran 90 para você mesmo testar o que foi apresentado acima.

Salve o programa abaixo num arquivo chamado teste.f90:

program teste
implicit none

integer :: i,j
real :: x,y,resultado

x=1
y=2

call soma(x,y,resultado)
call imprime(resultado)

end program teste

O programa abaixo deverá ser salvo num arquivo chamado sub1.f90:

subroutine soma(valor1,valor2,resultado)
implicit none
real :: valor1,valor2,resultado

resultado = valor1 + valor2

end subroutine

E, por fim, salve o programa abaixo num arquivo chamado sub2.f90:

subroutine imprime(valor)
implicit none
real :: valor

print *,valor

end subroutine

Pronto! Com estes arquivos você pode testar a funcionalidade dos arquivos makefile.

Juntando arquivos PDF num só

Num dia desses gerei dois documentos em PDF, por softwares distintos. A união dos conteúdos destes documentos era necessária, mas tornar-se-ia complicada e, muito provavelmente, perder-se-ia a fomatação de algum.

Para resolver esta questão procurei um jeito de unir os dois arquivos, tornando-os em um arquivo PDF apenas, cujo conteúdo poderia ser usado e entendido sem problemas. A solução surgiu no site Linux.com, na página intitulada: Putting together PDF files, que retransmito aqui.

Suponha que você gerou um texto no OpenOffice Writer e uma planilha eletrônica no OpenOffice Calc, dos quais foram produzidos dois arquivos PDF: texto.pdf e planilha.pdf. Por questões de pressa, você não quer perder tempo colando, copiando e arrumando a planilha no texto. Um arquivo PDF contendo estes dois é gerado facilmente digitando o comando abaixo num terminal do linux:

gs -dBATCH -dNOPAUSE -q -sDEVICE=pdfwrite -sOutputFile=textoFinal.pdf texto.pdf planilha.pdf

no qual tem-se:

gs -> chama o programa Ghostscript, que processará os arquivos PDF

-dBATCH -> sai do Ghostscript após processar os arquivos PDF

-dNOPAUSE -> faz o Ghostscript processar cada página sem pausas que permitam interação com o usuário

-q -> não deixa o Ghostscript exibir mensagens enquanto está em operação

-sDEVICE=pdfwriter -> avisa ao Ghostscript que deve ser usado o escritor PDF embutido (que acompanha o Ghostscript)

-sOutputFile=textoFinal.pdf -> informa ao Ghostscript o nome do arquivo que conterá a combinação dos arquivos texto.pdf e planilha.pdf.

O site que apresenta esta solução para a união de arquivos PDF mostra dois outros métodos. Entretanto, como esta página foi publicada em junho de 2004, uma das alternativas não é encontrada pelo link disponibilizado e o outro método usa um software pago.

O Ghostscript vem normalmente instalado na maioria das distribuições Linux. Isto torna mais prático o uso do comando acima para unir vários arquivos PDF num único arquivo PDF.

Um conhecimento mais aprofundado sobre o Ghostcript pode enriquecer ainda mais este processamento, mas isto foge o propósito deste post. Quem sabe, futuramente ...

Instalando o NCL no Fedora 12 ou superior

ATUALIZAÇÃO (22/04/2014):

Isso não é uma novidade propriamente dita, mas coloco essa atualização para que não ocorra mal entendidos na hora da instalação do NCL via comando yum, no sistema Fedora. A instalação do NCL no sistema Fedora não aparenta mais ter os problemas apontados abaixo.

Assim, de acordo com algumas experiências, tudo funciona de maneira normal no NCL instalado via comando yum no Fedora. Portanto, num sistema Fedora, instala-se facilmente o NCL com o comando:

yum install ncl*

sendo que este comando deve ser usado como administrador do sistema. O "*" com o "ncl" garante que todos os demais pacotes para o NCL sejam instalados. OBS.: Não há espaço entre "ncl" e "*".

Entretanto, cabe lembrar que para esse método de instalação (via comando yum) não é dado suporte pela equipe de desenvolvimento do NCL, mas é muito provável que o usuário responsável por esse método ajude ao se colocar alguma dúvida na lista de discussão do NCL.

------------------------- // ----------------------------------------

ATUALIZAÇÃO (29/09/2011):

Recentemente, evidenciei um problema sério com o NCL instalado via repositórios do Fedora. Ao tentar utilizar funções de manipulação de data, em particular a função ut_calendar, o NCL é abortado e recebo o seguinte aviso: Falha de segmentação (segmentation fault). Ainda não investiguei a causa, mas parece-me um problema com o pacote udunits2, que é instalado junto com o NCL, como dependência.

Portanto, em função deste problema, que surgiu em diferentes computadores, É FORTEMENTE NÃO RECOMENDADA a instalação do NCL por meio do procedimento apresentado abaixo. Ao menos enquanto não for encontrada uma solução.

Caso ele já tenha sido instalado, desinstale os pacotes instalados (apresentados na Figura abaixo) com o comando yum remove , sendo o nome do pacote a ser desinstalado.

Instale o NCL usando um dos dois métodos padrão citados abaixo.

--------------------- // -----------------------------------

Aquele que deseja instalar o NCL em um sistema Linux conhece, ao ler as informações sobre a sua instalação no site www.ncl.ucar.edu, que há dois métodos padrão para tal procedimento:

1) instalar os binários compilados pelos desenvolvedores do NCL, que requer o conhecimento da versão do GCC (GNU Compiler Collection), qual a distribuição Linux na qual ele será instalado e em que tipo de máquina o Linux se encontra, ou

2) compilar o código fonte do NCL; procedimento que necessita da compilação e/ou instalação de outros softwares.

O primeiro é o recomendado pelos desenvolvedores do NCL, pois não requer conhecimentos avançados de compilação e instalação em sistema Linux. Basta que o usuário certifique-se que o seu sistema satisfaça os itens requeridos - listados acima - e instale os arquivos nos locais apropriados. Maiores detalhes podem ser encontrados aqui.

O segundo método, apesar de permitir uma instalação mais personalizada (uma vez que o usuário habilitará apenas os recursos do NCL que lhe interessam), exige maior conhecimento sobre a compilação e instalação de programas a partir de códigos fontes. Provavelmente, este processo tomará muito mais tempo do usuário que o primeiro. Mais informações são encontradas aqui.

Infelizmente, nem todas as versões do GCC são contempladas com uma versão já compilada do NCL. Este fato, aliado à dificuldade do segundo processo de instalação, dificulta o uso do NCL por usuários iniciantes no ambiente Linux.

Nas últimas versões da distribuição Fedora (a partir da 12ª), o NCL está disponível nos repositórios de instalação desta distribuição, permitindo que o usuário instale o NCL por um terceiro caminho.

Para instalá-lo, digite no terminal (ou console), como root (administrador), a linha de comando abaixo:

yum install ncl*

na qual yum é o comando de instação e desinstalação de pacotes (nome dado a conjuntos de arquivos que constituem um programa), e install é a opção que informa ao comando yum que deseja-se instalar todos os pacotes cujos nomes começam com ncl.

Este procedimento requer conexão com a internet para que o yum acesse os repositórios de instalação do Fedora. Após a verificação da disponibilidade de pacotes, o comando yum mostrará todos os pacotes necessários à instalação do NCL, conforme mostrado abaixo.




Para instalar, basta digitar "s", para sim, e aguardar a finalização da instalação do NCL.

Para usar, basta digitar "ncl" no terminal. Se você está começando, dê uma olhada na documentação do NCL, em seu site, para ver detalhes do seu uso.

Instalação mal sucedida?

Tanto o usuário experiente quanto o usuário iniciante podem pensar, após alguns testes com o NCL, que ocorreu algum tipo de erro em sua instalação. Esta constatação surgirá ao se tentar rodar scripts do NCL - sejam aqueles disponibilizados nos exemplos do site, sejam aqueles escritos por usuários antigos - que requerem o carregamento à memória de scripts auxiliares como o gsn_code.ncl, o gsn_csm.ncl ou o contributed.ncl, por exemplo.

Na realidade não houve erro na instalação, mas sim uma diferença na localização destes arquivos, entre aquela usada por padrão e aquela usada na instalação do NCL no Fedora por este outro método. Por padrão, estes scritps são carregados da sequinte maneira, logo no início de um script NCL:

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

na qual load é o comando do NCL para carregar scripts na memória e $NCARG_ROOT é a variável de ambiente do Linux que indica onde o NCL está instalado. No Fedora, estes scripts estão instalados em /usr/share/ncarg/nclscripts. Como resultado, um script que usa a localização padrão destes arquivos auxiliares não funcionará. Para resolver isto, basta corrigir a localização dos mesmos, usando:

load "$NCARG_ROOT/share/ncarg/nclscripts/csm/gsn_code.ncl"

Neste caso, a variável $NCARG_ROOT é igual a /usr. Outro ponto negativo deste modo de instalação do NCL é a obtenção de suporte por meio da lista de e-mails disponibilizada pelos desenvolvedores do NCL. Como este método não é padrão e não é gerenciado por eles, os desenvolvedores não têm conhecimento pleno a respeito da compilação do NCL para disponibilização nos repositórios do Fedora, tornando complicada a obtenção de ajuda.

Instalando GrADS no Fedora 12

Eventualmente, ajudo alguns amigos com o GrADS. Entretanto, nos últimos tempos não o tenho instalado quando coloco um novo sistema em meu computador. Assim, para tentar ajudar os amigos vou correndo baixar o GrADS e instalá-lo.

Na última vez deparei-me com um problema interessante. Instalei o GrADS conforme explicado em sua documentação, mas ele não funcionava. Ao tentar executá-lo recebia a seguinte mensagem de erro:

gradsnc: error while loading shared libraries: libtermcap.so.2: cannot open shared object file: No such file or directory

De pronto fui pesquisar em sites que fornecem pacotes para o Fedora (versão 12, no meu caso!) para tentar encontrar algum que fornecesse a tal biblioteca. Infelizmente, nenhum pacote fornece esta biblioteca, que seriam a libtermcap e libtermcap-devel. Socorro final: fóruns de discussão, lista de usuários etc.

A solução foi encontrada no Fedoraforum.org (http://fedoraforum.org/forum/showthread.php?t=210569) que retransmito aqui.

Causa do problema: Os pacotes libtermcap-2.0.8-47.i386 e libtermcap-devel-2.0.8-47.i386 foram tornados obsoletos pelos pacotes ncurses-libs-5.7-3.20090207.fc12.i686 e ncurses-devel-5.7-3.20090207.fc12.i686. Nestes pacotes não há nenhuma biblioteca chamada libtermcap.so.2.

Solução: o pacote ncurses-libs-5.7-3.20090207.fc12.i686 fornece uma biblioteca chamada /lib/libtinfo.so.5.7, da qual pode-se criar um link simbólico que aponta para libtermcap.so.2 com o seguinte comando:

ln -s /lib/libtinfo.so.5.7 /usr/lib/libtermcap.so.2

Pronto!
É só usar o GrADS!

Nota importante:

Tenha muito cuidado ao aplicar uma possível solução ao seu problema. Use SEMPRE QUE POSSÍVEL os mecanismos de instalação e manutenção do seu sistema para resolver um problema. SOMENTE EM ÚLTIMO CASO, use procedimentos alternativos. Se alguma coisa ocorrer errado, o seu sistema pode parar ou sofrer danos sérios!

No site do fórum mencionado acima, uma das mensagens sugere a instalação de pacotes de uma versão anterior do Fedora, pois a solução transcrita acima não funcionou para a pessoa que pediu ajuda. No meu caso, eu testei a instalação destes pacotes usando o yum, o instalador de pacotes do Fedora. Baixei os arquivos sugeridos e entrei com o seguinte comando:

sudo yum --nogpgcheck localinstall libtermcap-2.0.8-47.i386.rpm libtermcap-devel-2.0.8-47.i386.rpm
Plugins carregados: presto, refresh-packagekit
Configurando o processo de pacote local
Examinando libtermcap-2.0.8-47.i386.rpm: libtermcap-2.0.8-47.i386
Marcando libtermcap-2.0.8-47.i386.rpm para ser instalado
O pacote libtermcap-2.0.8-47.i386 foi tornado obsoleto pelo ncurses-libs-5.7-3.20090207.fc12.i686, o qual já está instalado
Examinando libtermcap-devel-2.0.8-47.i386.rpm: libtermcap-devel-2.0.8-47.i386
Marcando libtermcap-devel-2.0.8-47.i386.rpm para ser instalado
O pacote libtermcap-devel-2.0.8-47.i386 foi tornado obsoleto pelo ncurses-devel-5.7-3.20090207.fc12.i686, o qual já está instalado
Nada a ser feito

Traduzindo, o sistema está avisando que os pacotes são obsoletos.

É melhor procurar outra solução!

NUNCA aplique "soluções" cegamente! SEMPRE teste antes!!!

Até a próxima!