M todos y t cnicas de an lisis de datos clim ticos e e a a

Jon S enz a 24 de febrero de 2007

1.

El pasado

2.

El presente

2.1.

Grandes repositorios de datos

Reanalisis del NCEP/NCAR http://www.cdc.noaa.gov/cdc/reanalysis/reanalysis.shtml Reanalisis del ECMWF http://www.ecmwf.int http://data.ecmwf.int/data/d/era40_daily/ Otros repositorios: British Atmospheric Data Centre http://badc.nerc.ac.uk/home/ IPCC Data Distribution Centre http://ipcc-ddc.cru.uea.ac.uk/ Jet Propulsion Laboratory, en CalTech www.jpl.nasa.gov UCAR, University Consortium for Atmospheric Research dss.ucar.edu

USGS, US Geological Survey http://www.usgs.gov/pubprod/digitaldata.html Proyectos especificos GEWEX - Global Energy and Water Exchange www.gewex.org IGBP, International Geosphere-Biosphere Program http://www.igbp.kva.se/cgi-bin/php/frameset.php

GOOGLE/Yahoo/....

2.2.

Ventajas
El dato num rico permite sacar el mapa mediante un programa de visualizaci n (ej, Z850 e o hPa). Adem s, a partir del dato num rico se pueden sacar mapas adicionales de otras magnitudes a e derivadas, sencillas (p. ej. espesor Z500-Z850) o complejas (p. ej. vorticidad potencial).

2.3.

Problemas varios

1. Representaci n digital de n meros (Int, Float) o u 2. Bigendian y Littleendian Alpha-DECIntel-Linu MacOSX SiliconGra Alpha-DECIntel-Linu MacOSX SiliconGra Int16: Int16: Int16: Int16: Int32: Int32: Int32: Int32: 1 1 1 1 8 8 8 8 : : : : : : : : 10000000 10000000 00000000 00000000 00010000 00010000 00000000 00000000 00000000 00000000 10000000 10000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000

00000000 00000000 0 00000000 00010000 00010000

Alpha-DECIntel-Linu MacOSX SiliconGra

Float32: Float32: Float32: Float32:

2.57e+12 2.57e+12 2.57e+12 2.57e+12

: : : :

00111111 00111111 00101010 00101010

11101001 11101001 10101000 10101000

10101000 10101000 11101001 11101001

00101010 00101010 00111111 00111111

3. Orden de los campos (p. ej. C y Fortran)

33 ARRAY 2D en MEMORIA 9 FORTRAN:

25 3

37 17

33 33

9 25

25 37

3 9

37 3

17 17

C:
2.4.

Sistemas de almacenamiento de datos

1. Datos crudos, sin estructurar ASCII Binario XDR 2. Datos estructurados (Cabecera + datos) Formatos especicos (p. ej. METAR) Formatos de uso m s general: a netCDF HDF GRIB XML

3. Otros m todos propietarios (ORACLE, ...) e

2.5.

Consideraciones para elegir un sistema

1. Espacio de almacenamiento 2. Facilidad de uso a) Disponibilidad en diversos S.O b) Disponibilidad en diversas plataformas de computaci n o c) Necesidad de elementos externos y/o licencias. 4

3. Tendencia al error 4. Posibilidades de pre y posttratamiento

3.
3.1.

UNIX
Porqu UNIX? e
1. Porque es el m s usado en universidades, centros de investigaci n y predicci n. a o o 2. Porque hay mucho software especco para la climatologa 3. Porque hay mucho software gratis 4. Porque es muy potente (Ej. scripts de shell, awk, etc...)

3.2.

UNIX. Conceptos b sicos a

Sesi n o Terminal Host Usuario y grupo Directorios Archivos Permisos (r,w,x,s...) shell pipes y redireccionamiento Trabajo en red (telnet, ftp, ssh, scp, rsync, NFS)

3.3.

Comandos seleccionados
man/apropos/info/whatis mkdir rm chmod cd ls mv lpr ps kill exit clear reset cat y more le startx Ctrl+Alt+Tab Informaci n (man man) o Crear un directorio (man mkdir) Eliminar un archivo Modicar los permisos Cambiar de directorio Listar el contenido de un directorio Renombrar un archivo/Moverlo a otra ubicaci n o Imprimir un archivo en una cola Ver los procesos activos Matar un proceso activo (enviarle una se al) n Abandonar la sesi n o Borrar pantalla Restaurar terminal ver contenido de cheros de texto (cat ficheron|more) Ver el tipo de un chero Arrancar el modo gr co a Acabar con el modo gr co a

3.4.

Otros detalles

1. Ficheros ocultos 2. Ficheros de inicializaci n o 3. Variables de entorno (HOME, PATH, DISPLAY,...) 4. wildcards 5. Control de procesos: a) at b) bg, fg c) nice

4.

Ficheros netCDF

Porqu escogemos cheros netCDF? netCDF (network Common Data Form) es un formato e muy com n con grandes ventajas: u 1. Representaci n binaria independiente de la m quina o a 2. Con convenciones, los cheros tienen una cabecera que dene los datos 3. Soportado por la mayora de software de representaci n y tratamiento de datos o 4. Soportado por una de las instituciones americanas de mayor importancia en el campo de la meteorologa
http://www.unidata.ucar.edu/packages/netcdf/index.html

Ejemplo de datos netCDF gratuitos (uso no comercial). 1. Variables atmosf ricas de los rean lisis del NCEP e a
http://www.cdc.noaa.gov/cdc/reanalysis/

2. Datos oce nicos (SST, LHTFLX, SLP, ...) de COADS a

http://www.cdc.noaa.gov/coads/coads_cdc_netcdf.shtml

3. Datos analizados de SST

http://www.cdc.noaa.gov/cdc/data.reynolds_sst.html

4. Datos OLR procedentes de sat lite. e

http://www.jisao.washington.edu/data_sets/olr/

4.1.

Otros sistemas

netCDF no es el unico sistema est ndar de archivo de datos meteorol gicos: a o a GRIB en los Rean lisis del ECMWF
http://www.ecmwf.int

GRIB en los Rean lisis del NCEP (CDROM) a HDF en mucha informaci n satelitaria de radiaci n. o o
http://www.archive.arm.gov/data/hdfnews.html

Otros formatos ASCII o binarios Por razones de tiempo, nosotros solamente vamos a ver el tratamiento de datos en formato netCDF, pero el alumno puede ver la manera de trabajar con datos GRIB o HDF en las fuentes originales: 1. HDF (Hierarchical Data Format)
http://hdf.ncsa.uiuc.edu/

2. GRIB (GRIdded Binary)

http://www.wmo.ch/web/www/reports/Guide-binary-2.html

Para cheros grib, la herramienta wgrib es muy util.

jsaenz@lcux24:/gasherbrum/data> wgrib -V output.grib |head -n 10 rec 1:0:date 1957090100 Z kpds5=129 kpds6=100 kpds7=500 levels=(1,244) grid=255 500 mb ECMWF type? mon mean anl:ave@24hr: Z=Geopotential [m**2 s**-2] timerange 123 P1 0 P2 24 TimeU 1 nx 144 ny 73 GDS grid 0 num_in_ave 30 missing 0 center 98 subcenter 0 process 199 Table 128 scan: WE:NS winds(N/S) latlon: lat 90.000000 to -90.000000 by 2.500000 nxny 10512 long 0.000000 to 357.500000 by 2.500000, (144 x 73) scan 0 mode 128 bdsgrid 1 min/max data 46956.8 57950.6 num bits 16 BDS_Ref 46956.8 DecScale 0 BinScale -2 rec 2:21240:date 1957090106 Z kpds5=129 kpds6=100 kpds7=500 levels=(1,244) grid=255 500 mb ECMWF type? mon mean anl:ave@24hr: Z=Geopotential [m**2 s**-2] jsaenz@lcux24:/gasherbrum/data> [...] jsaenz@lcux24:/gasherbrum/data> wgrib output.grib|wgrib -d 4 -ieee -o record4.bin output.grib 1:0:d=57090100:Z:kpds5=129:kpds6=100:kpds7=500:TR=123:P1=0:P2=24:TimeU=1:500 mb:anl:ave@24hr:ECMWF type?:mon mean:NAve=30 jsaenz@lcux24:/gasherbrum/data> jsaenz@lcux24:/gasherbrum/data> ls -si *bin 11403269 44 record4.bin jsaenz@lcux24:/gasherbrum/data>

4.2.

Contenido de un chero netCDF

Un chero netCDF (fichero.nc o fichero.cdf) es binario. Por tanto, no es posible ver directamente su contenido. Pero se puede convertir su contenido a una representaci n ASCII o relativamente comprensible para un humano.
ncdump -h /home/jsaenz/meteoclimadata/olrdata.nc

Tambien se puede convertir por completo el chero en un chero ASCII (CDL) a costa de gastar mucho mas espacio de disco:

ncdump /home/jsaenz/meteoclimadata/olrdata.nc > olrdata.cdl ls -l /home/jsaenz/meteoclimadata/olrdata.nc olrdata.cdl |awk {printf("%d %s\n",$5,$9 rm -f olrdata.cdl

6311212 /home/jsaenz/meteoclimadata/olrdata.nc 20842909 olrdata.cdl

Hay cheros de denici n m s o menos complicada: o a

ncdump -h /home/jsaenz/meteoclimadata/surface/slp.mon.mean.nc

4.3.

Resultado de los comandos anteriores1

netcdf olrdata { dimensions: lat = 73 ; lon = 144 ; time = UNLIMITED ; // (300 currently) variables: float lat(lat) ; lat:title = "Latitude" ; lat:units = "degrees_north" ; lat:scale_factor = 1.f ; lat:add_offset = 0.f ; float lon(lon) ; lon:title = "Longitude" ; lon:units = "degrees_east" ; lon:scale_factor = 1.f ; lon:add_offset = 0.f ; double time(time) ; time:title = "Time" ; time:units = "hours since 1974-01-15 0:0:0" ; time:scale_factor = 1.f ; time:add_offset = 0.f ; short data(time, lat, lon) ; data:long_name = "W m-2" ; data:add_offset = 200.f ; data:scale_factor = 0.01f ; data:missing_value = 32767s ; data:units = "W m-2" ; }

netcdf slp.mon.mean { dimensions: lon = 144 ; lat = 73 ; time = UNLIMITED ; // (643 currently) variables: float lat(lat) ; lat:units = "degrees_north" ; lat:actual_range = 90.f, -90.f ; lat:long_name = "Latitude" ; float lon(lon) ; lon:units = "degrees_east" ; lon:long_name = "Longitude" ; lon:actual_range = 0.f, 357.5f ; double time(time) ; time:units = "hours since 1-1-1 00:00:0.0" ; time:long_name = "Time" ; time:actual_range = 17067072., 17536032. ; time:delta_t = "0000-01-00 00:00:00" ; time:prev_avg_period = "0000-00-00 06:00:00" ; float slp(time, lat, lon) ; slp:long_name = "Sea Level Pressure" ; slp:valid_range = 870.f, 1150.f ; slp:actual_range = 962.8222f, 1082.558f ; slp:units = "millibars" ; slp:add_offset = 0.f ; slp:scale_factor = 1.f ; slp:missing_value = -9.96921e+36f ; slp:precision = 1s ; slp:least_significant_digit = 1s ; slp:var_desc = "Sea Level Pressure\n", "P" ; slp:dataset = "CDC Derived NCEP Reanalysis Products\n", "AC" ; slp:level_desc = "Sea Level\n", "I" ; slp:statistic = "Mean\n", "M" ; slp:parent_stat = "Other\n", "-" ;

// global attributes: :title = "monthly mean slp from the NCEP Reanalysis" ; :history = "Thu May 4 18:12:35 2000: ncrcat -d time,0,622 /Datasets/ncep.reanalys "Mon Jul 5 23:22:35 1999: ncrcat slp.mon.mean.nc /Datasets/ncep.reanalysis.derive "/home/hoop/crdc/cpreanjuke2farm/cpreanjuke2farm Thu Oct 26 23:42:16 1995 from pre "created 95/02/06 by Hoop (netCDF2.3)" ; :description = "Data is from NMC initialized reanalysis\n", "(4x/day). These are the 0.9950 sigma level values." ; :platform = "Model" ; :Conventions = "COARDS" ; }

4.4.

Estructura de los cheros netCDF

Dimensiones: Tienen un nombre y una longitud y especican el tama o de cada eje de n una matriz de datos. Puede existir una unica dimensi n nula, que especica una matriz que o puede crecer en ese eje. a u Variables: Se utilizan para almacenar datos y tienen car cter de arrays o listas de n meros (un escalar es un array de dimensi n nula). Una variable tiene asociado un nombre, un tipo o y una forma que se denen durante la creaci n. Una variable puede tener tambi n asociados o e diversos atributos. Atributos: Las variables (y el propio chero) pueden tener asociados ciertos atributos, que sirven para describir el contenido de la variable o el chero (atributos globales). De acuerdo con ciertas convenciones, ciertos atributos tienen signicados especiales. Entre otros: add offset, o scale factor, s. Se usa: xreal = sxarchivo + o missing value units

Una descripci n exhaustiva de estos conceptos existe en la documentaci n ocial: o o

http://www.unidata.ucar.edu/packages/netcdf/guidec/

4.5.

Convenciones netCDF

Un chero netCDF puede tener estructuras arbitrarias y cada programa sabr como interpretarlo. a
netcdf IPtopo { dimensions: side = 2 ; xysize = 21901 ; variables: double x_range(side) ; x_range:units = "user_x_unit" ; double y_range(side) ; y_range:units = "user_y_unit" ; double z_range(side) ; z_range:units = "user_z_unit" ; double spacing(side) ; int dimension(side) ; float z(xysize) ; z:scale_factor = 1. ; z:add_offset = 0. ; z:node_offset = 0 ; // global attributes: :title = "surface" ; }

netcdf pl1+2pdf { dimensions: dimx = 161 ; dimy = 161 ; variables: double X(dimx) ; double Y(dimy) ; double PDF(dimx, dimy) ; // global attributes: :Bandwidth = "1.26336" ; }

En meteorologa, los programas de visualizaci n interpretan habitualmente las convenciones o COARDS: Variables coordenadas: Latitud, longitud, tiempo, nivel

10

Unidades en las variables coordenadas Orden en los ejes: T, Z, Lat, Lon

http://www.unidata.ucar.edu/packages/netcdf/conventions.html

4.6.

Programas de visualizaci n o c lculo o a

1. NcView http://meteora.ucsd.edu/pierce/ncview_home_page.html 2. GrADS http://grads.iges.org/grads/ 3. Python y Scientic Python http://www.python.org 4. CDAT http://www-pcmdi.llnl.gov/software/cdat/ 5. Ferret http://ferret.wrc.noaa.gov/Ferret/ 6. Freud http://www.atmos.washington.edu/jisao/freud 7. NCO http://nco.sourceforge.net 8. IBM DataExplorer http://www.research.ibm.com/dx/ 9. Vis5D http://www.ssec.wisc.edu/billh/vis5d.html Nosotros vamos a centrarnos en el uso del programa GrADS. Existe documentaci n sobre el o uso de este programa en la p gina WEB correspondiente: a
http://grads.iges.org/grads/

11

5.

python como lenguaje de an lisis de datos a

Python (http://www.python.org) es un lenguaje de programaci n interpretado de ultio ma generaci n, orientado a objetos, con acceso a libreras de uso general (desde sistemas de mano tenimiento de servidores WWW hasta libreras de manejo de arm nicos esf ricos como SPHERE o e PACK. Es un lenguaje en la lnea de otros como matlab, pero frente a este, es de uso libre. Frente a otros lenguajes m s tradicionales (C, Fortran), es de uso mucho m s sencillo. a a Ejemplos de funciones en C para cargar datos de cheros netCDF:
#include #include #include #include #include <stdio.h> <string.h> <stdlib.h> <netcdf.h> <gsl/gsl_vector.h>

void __check_nc_error( int err , char *file , int lineno ) { if(err!=NC_NOERR){ fprintf(stderr,"Error %d writing netCDF file:\nLine:%d\nFile:%s\n",err, lineno,file); fprintf(stderr,"Error message:%s\n",nc_strerror(err)); exit(1); } } int save_date_string( int ncid , char *attrname , char *datestr ) { int status; status=nc_put_att_text(ncid,NC_GLOBAL,attrname,strlen(datestr), datestr); check_nc_error(status); return status == NC_NOERR; } long get_dim_value( int ncid , char *dimname ) { int dimid; int status; size_t thesize; status=nc_inq_dimid(ncid,dimname,&dimid); check_nc_error(status); status=nc_inq_dimlen(ncid,dimid,&thesize); check_nc_error(status); return (long)thesize; } int read_vector(int ncid, char *varname, gsl_vector *v ) { int status; int varid; size_t count[1]; size_t start[1]; double *dptr;

12

start[0]=0; count[0]=v->size; dptr=gsl_vector_ptr(v,0); status=nc_inq_varid(ncid,varname,&varid); check_nc_error(status); status=nc_get_vara_double(ncid,varid,start,count,dptr); check_nc_error(status); return status=NC_NOERR; }

Funciones python equivalentes:

from Scientific.IO.NetCDF import * from Numeric import * def save_date_string(oncfile,attrname,datestr): setattr(oncfile,attrname,datestr) def get_dim_value(incfile,dimname): return incfile.dimensions[dimname] def readvector(incfile,varname): return array(incfile.variables[varname][:])

Ventajas: Es interpretado y es f cil buscar un error en forma interactiva. a El c digo se escribe muy f cil. o a Las extensiones num ricas hacen que la velocidad de ejecuci n sea aceptable, excepto pae o ra aquellos trabajos que no se adec en al esquema de funcionamiento puramente matriu cial/vectorial. Es f cilmente extensible mediante libreras din micas escritas en C o Fortran para los traa a bajos m s pesados. a Es muy potente para uso general adicional al c lculo. a

5.1.

Ejemplos de entrada de datos

Lectura del chero siguiente como un conjunto de valores:

1 2 3 4 5 0.1 2 .01 4 .001 8 .0001 16 .00001 32

Se puede leer mediante el programa:

13

# definamos una funcion para leer una tabla de datos # (matriz bidimensional) def tokens2list(toks): elist=[] for i in xrange(len(toks)): elist.append(eval(toks[i])) return elist def readdat(filename): ifile=open(filename) data=[] for l in ifile.readlines(): toks=l.split() if len(toks)>0: data.append(tokens2list(toks)) return data print readdat("ejemplo.dat")

Resultados:

[[1, 0.10000000000000001, 2], [2, 0.01, 4], [3, 0.001, 8], [4, 0.0001, 16], [5, 1.0000

Pero es interesante en este tipo de cheros ASCII a adir algunos comentarios que describan n lo que es cada columna y as.
# # # # 1 2 3 4 5 i 10{-i} 2i Comentario util (identificar fuente de datos, condiciones de la simulacion, unidades o contenido de cada columna, etc...) 0.1 2 .01 4 .001 8 .0001 16 .00001 32

Se puede leer mediante el programa:

# definamos una funcion para leer una tabla de datos # (matriz bidimensional) def tokens2list(toks): elist=[] for i in xrange(len(toks)): elist.append(eval(toks[i])) return elist def readdat(filename): ifile=open(filename) data=[] for l in ifile.readlines(): toks=l.split() if len(toks)>0: if toks[0][0]=="#": continue else:

14

data.append(tokens2list(toks)) return data print readdat("ejemplo2.dat")

Resultados:

[[1, 0.10000000000000001, 2], [2, 0.01, 4], [3, 0.001, 8], [4, 0.0001, 16], [5, 1.0000

Y es a n m s interesante devolver los resultados en forma de array num rico: Se puede leer u a e mediante el programa:
# definamos una funcion para leer una tabla de datos # (matriz bidimensional) # Agnade la vuelta como un array de datos de tipo Numeric import Numeric def tokens2list(toks): elist=[] for i in xrange(len(toks)): elist.append(eval(toks[i])) return elist def readdat(filename): ifile=open(filename) data=[] for l in ifile.readlines(): toks=l.split() if len(toks)>0: if toks[0][0]=="#": continue else: data.append(tokens2list(toks)) return Numeric.array(data) print readdat("ejemplo2.dat")

Resultados:
[[ [ [ [ [ 1.00000000e+00 2.00000000e+00 3.00000000e+00 4.00000000e+00 5.00000000e+00 1.00000000e-01 1.00000000e-02 1.00000000e-03 1.00000000e-04 1.00000000e-05 2.00000000e+00] 4.00000000e+00] 8.00000000e+00] 1.60000000e+01] 3.20000000e+01]]

5.2.

Salida de datos

Para comunicar datos al usuario se pueden sacar por salida est ndar o grabar en un chero: a
# print es facil de usar # Salvo que se cambien las cosas, saca # los valores por salida estandar # sin formatear print 5 i=10.4e-25

15

b=.098 print i,b print "Hola" c="Adios" print "hola"+c print "Hola "*4 # Pero tambien es posible formatear la salida ####################################### print "%12.3f %12.3e %6.6d %6d"%(b,b,10,10)

# write() se usa tras abrir un fichero # El formato de la salida se controla ###################################### ofile=open("ejemplo.write","w") ofile.write("%d\n"%(5,)) ofile.write("%s-%s-%s"%("Hola",c,c)) ofile.write("\n\n"*2) entero=12 real=12.5674123 s1="String" s2="*"*12 ofile.write("%d %f %12.3f|%10s|%-10s|%s\n"%(entero,real,real,s1,s1,s2)) ofile.close()

Resultados por salida est ndar: a

5 1.04e-24 0.098 Hola holaAdios Hola Hola Hola Hola 0.098 9.800e-02 000010

10

Y el chero que acabamos de crear (ejemplo.write):

5 Hola-Adios-Adios

12 12.567412

12.567|

String|String

|************

5.3.

Creando diferentes tipos de cheros

En esta script se demuestra c mo es posible crear cheros ASCII, binarios nativos de la platao forma donde se ejecuta el c digo y binarios netCDF: o
import struct ######## # Ficheros tipo ASCII # Cada caracter de una cadena, numero, lo que sea, se # representa tal cual se escribe. #

16

# Exigen mucho espacio y tiempo de CPU, pero se # interpretan y analizan bien, y son comunes en # "todas" las maquinas. ################## ofile=open("ejemplo.ascii","w") ofile.write("%f %f %d %f %f %f\n"%(3.51234,123673.6,3000,10009.0,10000.001,0.0001)) ofile.close()

######## # Ficheros binarios # Cada variable se representa por la sucesion de bits que # se emplea en la memoria y el procesador. # # Exigen mucho menos espacio y tiempo de CPU, pero NO se # interpretan y analizan bien, y NO son comunes en # "todas" las maquinas. ################## string_data=struct.pack("ddiddd",3.51234,123673.6,3000,10009.0,10000.001,0.0001) ofile=open("ejemplo.binario","w") ofile.write(string_data) ofile.close()

########################################## # Otros tipos de archivos mas complejos # Tienen las ventajas de ocupar el tamagno # de los ficheros binarios, pero son compatibles # entre maquinas incompatibles ############################################ from Scientific.IO.NetCDF import * from Numeric import * onc=NetCDFFile("ejemplo.cdf","w") onc.createDimension("iitems",1) onc.createVariable("entera",Int,("iitems",)) onc.variables["entera"][0]=3 onc.createDimension("fitems",5) onc.createVariable("real",Float64,("fitems",)) onc.variables["real"][0]=3.5 ovar=onc.variables["real"] ovar[1]=3.6 ovar[2]=9.0 ovar[3]=10000.001 ovar[4]=0.0001 onc.close()

Tama os de los cheros: n Nombre ejemplo.binario ejemplo.ascii ejemplo.cdf 17 bytes 44 63 184

5.4.

Control de ujo

Sentencias de control de ujo:

# Control de flujo: # # IF.... (condiciones) A=1 if A: print "A!=0" if A==1: print "A es exactamente 1" if A<>2: print "A NO es 2" if 0<A<=3: print "A pertenece a (0,3]" B=3.5 # Condiciones mezcladas if A==1 and B<4: print "He pasado" # Ciclos FOR # Para generar ciclos de numeros ################################ for i in xrange(10): print i,2*i+1,"|", print # Ciclos FOR para otras utilidades ################################## # Caracteres en una string str="Esto es una string" for c in str: print c,"-", print # Elementos de una lista ########################## lista=[1,3,5,7,9,11] for l in lista: print l,"-", print # Elementos en un diccionario ############################### dict={0:"Cero",1:"Uno",2:"Tres"} lista=dict.keys() lista.sort() for l in lista: print l,": %s -"%(dict[l],), print # Ciclo WHILE t=0. dt=2.5 while t<10: print t,"|", t+=dt print

18

# Salir de ciclos o permanecer en ellos: break y continue # % es el operador modulo print "12%24=",12%24,", 6%3=",6%3,", 4%3=",4%3 i=1 while 1: if i==10: break if i%2==0: print i,"es par" else: print i,"es impar" i+=1 print

Resultados:
A!=0 A es exactamente 1 A NO es 2 A pertenece a (0,3] He pasado 0 1 | 1 3 | 2 5 | 3 7 | 4 9 | 5 11 | 6 13 | 7 15 | 8 17 | 9 19 | E - s - t - o - e - s - u - n - a - s - t - r - i - n - g 1 - 3 - 5 - 7 - 9 - 11 0 : Cero - 1 : Uno - 2 : Tres 0.0 | 2.5 | 5.0 | 7.5 | 12%24= 12 , 6%3= 0 , 4%3= 1 1 es impar 2 es par 3 es impar 4 es par 5 es impar 6 es par 7 es impar 8 es par 9 es impar

5.5.

Trabajo con arrays de Numeric

En este codigo se calcula una sinusoide por el m todo normal de control de ujo (ciclos) y e mediante el uso de funciones sobre arrays num ricos: e
# Dos alternativas para calcular cosas, CON y SIN Numeric import time import Numeric import math import profile

# Vamos a calcular una sinusoidal sin(w*t_i+phi) para 50000 puntos # Y devolvemos los valores def sinusoide_sin_N(): omega=0.234

19

phi=.98 dt=0.001 y=[] for i in xrange(500000): ti=i*dt y.append(math.sin(omega*ti+phi)) return y # Y ahora, haciendo uso de "vectores" (arange es otro interes...) ################################################################# def sinusoide_con_N(): omega=0.234 phi=.98 dt=0.001 ts=Numeric.arange(0.,500000*dt+dt/2.,dt) ############################################ # Numeric.sin() y math.sin() NO son lo mismo ############################################ y=Numeric.sin(omega*ts+phi) return y def main(): sinusoide_sin_N() sinusoide_con_N() profile.run(main())

Y este es el tiempo de CPU necesario para ambas funciones:

5 function calls in 2.130 CPU seconds Ordered by: standard name ncalls 1 1 0 1 1 1 tottime 0.000 0.010 0.000 1.720 0.360 0.040 percall 0.000 0.010 1.720 0.360 0.040 cumtime 2.120 2.130 0.000 1.720 0.360 2.120 percall filename:lineno(function) 2.120 <string>:1(?) 2.130 profile:0(main()) profile:0(profiler) 1.720 ufuncs.py:10(sinusoide_sin_N) 0.360 ufuncs.py:22(sinusoide_con_N) 2.120 ufuncs.py:33(main)

Esto obliga a cambiar de registro mental para calcular la derivada de y = x2 :

from Numeric import * from os import times # # Cambiando el esquema mental para usar Numeric # nx = 100000 xs = arange(nx)/10. ys = xs**2 #

20

# Empezamos a medir el tiempo # t0 = times()[-1] # # Calculo de la derivada 1 # # Usamos arrays de Numeric, pero no aprovechamos su potencial # dys_1 = zeros((nx,), Float32) for i in range(1,len(xs)-1): dys_1[i] = (ys[i+1] - ys[i-1]) / (xs[i+1] - xs[i-1]) # # Tiempo! # t1 = times()[-1] print "t1 =", t1 - t0 # # Calculo de la derivada 2 # # Usamos arrays de Numeric y aprovechamos su potencial # xsp1 = xs[2:] xsm1 = xs[:-2] xs = xs[1:-1] ysp1 = ys[2:] ysm1 = ys[:-2] ys = ys[1:-1] dys_2 = (ysp1 - ysm1) / (xsp1 - xsm1) # # Tiempo! # t2 = times()[-1] print "t2 =", t2 - t1 # # Comprobamos que el resultado es el mismo # print " x y dy1 dy2" print "---- " * 4 for i in range(20): print "%4.2f %4.2f %4.2f %4.2f" % (xs[i], ys[i], dys_1[i+1], dys_2[i])

a a Los resultados indican que el segundo camino es m s r pido.

t1 = 0.683333329856 t2 = 0.116666667163 x y dy1 dy2 ---- ---- ---- ---0.10 0.01 0.20 0.20 0.20 0.04 0.40 0.40 0.30 0.09 0.60 0.60 0.40 0.16 0.80 0.80 0.50 0.25 1.00 1.00 0.60 0.36 1.20 1.20

21

0.70 0.80 0.90 1.00 1.10 1.20 1.30 1.40 1.50 1.60 1.70 1.80 1.90 2.00

0.49 0.64 0.81 1.00 1.21 1.44 1.69 1.96 2.25 2.56 2.89 3.24 3.61 4.00

1.40 1.60 1.80 2.00 2.20 2.40 2.60 2.80 3.00 3.20 3.40 3.60 3.80 4.00

1.40 1.60 1.80 2.00 2.20 2.40 2.60 2.80 3.00 3.20 3.40 3.60 3.80 4.00

Por ello, en muchos casos, hay que pensar en nuevas maneras de calcular cantidades tpicas de, por ejemplo, la estadstica b sica. a

from Numeric import * from RandomArray import normal # # Distribucion normal aleatoria # 0.4 -> media # 0.7 -> desviacion estandar # 1000 -> numero de elementos (forma del array) # nor = normal(0.4, 0.7, (1000,)) nelems = float(len(nor)) print print "media" med = add.reduce(nor) / nelems print med print print "varianza" var = add.reduce((nor-med)**2) / nelems print var print print "desvacion estandar" std = sqrt(var) print std nor2 = normal(0.4, 0.7, (1000,)) med2 = add.reduce(nor2) / nelems std2 = sqrt(add.reduce((nor2-med2)**2) / nelems) print print "correlacion" print add.reduce((nor-med)*(nor2-med2)) / (nelems * std * std2)

22

Resultado:
media 0.407146954524 varianza 0.474909340305 desvacion estandar 0.689136663011 correlacion 0.0521791057784

5.6.

Algebra lineal

Hay libreras escritas en forma nativa en C o Fortran para las funciones matem ticas m s avan a a zadas, como algebra lineal (en el ejemplo presentado), FFT, n meros aleatorios para simulaciones u Monte Carlo, etc...

from Numeric import * from LinearAlgebra import inverse, eigenvalues, eigenvectors, singular_value_decomposi from pprint import pprint A = array( [[1, 0, 1], [0, -1, 1], [1, 0, -1]] ) b = array([1, 0, 0]) b.shape = (3,1) print print "A" print A print print "b" print b print print "I" print identity(3) print print "Ab" print dot(A,b) print print "Ax = b ==> x = Ab" print dot(inverse(A), b)

23

print print "Normalizar A" print A / sqrt(add.reduce(A*A)) print print "Valores y vectores propios de A" autoval, autovec = eigenvectors(A) print autoval print autovec print print "Comprobacion: Av1 = l1 v1 = -1 v1" print dot(A, autovec[0]) print print "SVD de A" pprint(singular_value_decomposition(A))

Resultados:
A [[ 1 0 1] [ 0 -1 1] [ 1 0 -1]] b [[1] [0] [0]] I [[1 0 0] [0 1 0] [0 0 1]] Ab [[1] [0] [1]] Ax [[ [ [ = b ==> 0.5] 0.5] 0.5]] x = Ab

Normalizar A [[ 0.70710678 0. [ 0. -1. [ 0.70710678 0.

0.57735027] 0.57735027] -0.57735027]]

Valores y vectores propios de A [-1. 1.41421356 -1.41421356] [[ 0. 1. 0. ] [ 0.91248696 0.15655801 0.37796447]

24

[-0.15655801 -0.91248696

0.37796447]]

Comprobacion: Av1 = l1 v1 = -1 v1 [ 0. -1. 0.] SVD de A (array([[-0.5 , -0.70710678, -0.5 ], [-0.70710678, 0. , 0.70710678], [ 0.5 , -0.70710678, 0.5 ]]), array([ 1.84775907, 1.41421356, 0.76536686]), array([[ 0. , 0.38268343, -0.92387953], [-1. , -0. , -0. ], [ 0. , -0.92387953, -0.38268343]]))

5.7.

Programaci n orientada a objetos o

En este ejemplo trivial, hay una lista de objetos (crculos, cuadrados, tri ngulos) que comparten a una funci n com n (su area) pero cada instancia (elemento concreto de la lista) sabe c mo se o u o calcula en su caso:
# Clases, ejemplo trivial import math class Figura: def yo_soy(self): return self.nombre class Circulo(Figura): def __init__(self,radio): self.nombre="Circulo de radio:%g"%(radio,) self.radio=radio def area(self): return math.pi*self.radio*self.radio class Cuadrado(Figura): def __init__(self,lado): self.nombre="Cuadrado de lado:%g"%(lado,) self.lado=lado def area(self): return self.lado*self.lado class Triangulo(Figura): def __init__(self,base,altura): self.nombre="Triangulo de base y altura:%g %g"%(base,altura) self.base=base self.altura=altura def area(self): return self.base*self.altura*0.5

def area_total(lista_figuras): total=0.0

25

for fig in lista_figuras: area=fig.area() total+=area print fig.yo_soy(),"Area:",area,"m2" return total if __name__=="__main__": lista_figuras=[ Circulo(4.5), Cuadrado(3.9), Cuadrado(2.5), Triangulo(8.,9.) ] print "Area total: %g m2"%(area_total(lista_figuras),)

Resultado:
Circulo de radio:4.5 Area: 63.6172512352 m2 Cuadrado de lado:3.9 Area: 15.21 m2 Cuadrado de lado:2.5 Area: 6.25 m2 Triangulo de base y altura:8 9 Area: 36.0 m2 Area total: 121.077 m2

5.8.

Lectura de datos en cheros netCDF

from Scientific.IO.NetCDF import * from Numeric import * from pprint import pprint # Abrir un fichero para LECTURA ############################### inc=NetCDFFile("/home/jsaenz/meteoclimadata/pressure/hgt.mon.mean.nc") # Lista de variables con informacion extra (no sabemos como se llaman) ###################################################################### keys=inc.variables.keys() keys.sort() print "Lista de variables (nombre, dimensiones, tipo:" for k in keys: print k, print inc.variables[k].shape, print inc.variables[k].typecode() # Cargar las variables coordenadas en arrays de Numeric ############################# # Esta, en su precision original lats=array(inc.variables["lat"][:]) # Esta, en doble precision lons=array(inc.variables["lon"][:],Float64) # Numero de registros temporales records_A=inc.variables["hgt"].shape[0] records_B=inc.dimensions["time"] records=len(inc.variables["hgt"])

26

# El metodo B no funciona en dimensiones de tipo NONE!! print records, records_A, records_B # Calculo de la media temporal de la media zonal de # Z en los meses de enero (el fichero empieza en el registro 0) ################################################################# hgt=inc.variables["hgt"] avezonal=zeros((hgt.shape[1],hgt.shape[2]),Float64) count=0 for i in xrange(0,records,12): zonal=add.reduce(hgt[i,:,:,:],2)/hgt.shape[3] avezonal=zonal+avezonal count+=1 avezonal=avezonal/count print "Forma de la media zonal:", print avezonal.shape,"=(",inc.dimensions["level"],",",len(lats),")???" # Valor de la serie temporal en un punto, nivel 11 print "Nivel:",inc.variables["level"][10],"hPa" print "Latitud:",lats[20],"N" print "Longitud:",lons[79],"E" serie=hgt[:,10,20,79] Lista de variables (nombre, dimensiones, tipo: hgt (659, 17, 73, 144) f lat (73,) f level (17,) f lon (144,) f time (659,) d 659 659 None Forma de la media zonal: (17, 73) =( 17 , 73 )??? Nivel: 150.0 hPa Latitud: 40.0 N Longitud: 197.5 E

27

6.
6.1.

Gr cos a
Gr cos de datos 1-D a

Se recomienda por su sencillez y potencia el uso del programa gnuplot, disponible de forma p blica para muchas plataformas diferentes (www.gnuplot.info). Sus instrucciones se pueu den dar en forma de comandos interactivos o en forma de cheros de instrucciones secuenciales que generan un archivo gr co (es programable). a 6.1.1. Gr co de lneas a Dibujo de una funci n. El siguiente chero dibuja dos versiones de una funci n sinusoidal o o sencill. La primera vez el programa escoge los par metros b sicos del dibujo. La segunda a a vez, lo escogemos nosotros. Ejecutamos la script: gnuplot funcion.plt.
# lo minimo total # Definir como dispositivo de salida un archivo de tipo pdf set term pdf # Darle nombre ############ set output "funcion.pdf" # Funcion que vamos a dibujar ############### f(x)=10*sin(3*x+1.23) # El resto lo escoje el... ##################### plot f(x) # # Mayor control de la situacion por nuestra parte ################################## set output "funcion2.pdf" set xrange [-5:3] set yrange [-20:15] set xlabel "Abscisa" set ylabel "Ordenada" plot f(x) title "Mi funcion" w lines linewidth 9

Resultados:
10 f(x) 8 10 6 4 2 0 -2 -4 -6 -8 -20 -10 -10 -5 -5 0 5 10 -4 -3 -2 -1 Abscisa 0 1 2 3 -10 5 15 Mi funcion

Ordenada

-5

-15

Leemos los valores de un chero de entrada. Cambiamos el tipo de gr co a gr cos de tipo a a scatter-plot. Esta vez el propio archivo llama a gnuplot.

28

gnuplot << EOF set term postscript eps color set out "duffing.eps" set xlabel "X1" set ylabel "X2" plot "duffing.res" using 2:3 t "" w d lw 6 EOF
1 0.8 0.6 0.4 0.2 X2 0 -0.2 -0.4 -0.6 -0.8 -1 -1.5

-1

-0.5

0 X1

0.5

1.5

Concentraci n de di xido de carbono en Mauna Loa. En este caso dibujamos el contenido o o de un chero en el que se almacena la concentraci n de CO2 en Mauna Loa. El problema es o que los puntos donde el valor es -99.99 son puntos donde no hay ning n valor, se ha perdido u (missing).
set term pdf set out "co2.pdf" plot "co2.dat" using 1:($2 < 0?1/0:$2) t "CO2" w lp lw 3 ps .5
380 CO2

370

360

350

340

330

320

310 1955

1960

1965

1970

1975

1980

1985

1990

1995

2000

2005

6.2.

Gr cos de datos 2-D the easy way (grads) a

GrADS (Grid Analysis and Display System, http://grads.iges.org) es posiblemente uno de los sistemas gr cos m s sencillos y a la vez potentes para representar y hacer c lculos a a a 29

sencillos en datos meteorol gicos y oce nicos, especialmente si el conjunto de datos original ya o a est expresado en una malla regular. El tratamiento de datos en estaciones individuales es posible, a pero es m s complicado. Existe un buen tutorial en el servidor del sistema: a http://grads.iges.org/grads/gadoc/tutorial.html 6.2.1. Gr co trivial a

Partiendo de un chero de datos 3D (T,LAT,LON), (por ejemplo, presi n supercial a nivel o del mar) representar los contornos de la media de los eneros de ese campo (el primer registro del chero correspondiente es enero).
grads -pb <<EOF sdfopen /home/jsaenz/meteoclimadata/surface/slp.mon.mean.nc set clevs 988 992 996 1000 1004 1008 1012 1016 1020 1024 1028 set grads off d ave(slp,t=1,t=659,12) draw title SLP Enero enable print slp-enero.gm print disable print quit EOF gxeps slp-enero.gm rm slp-enero.gm epstopdf slp-enero.eps

6.2.2.

Complicando las cosas un poco m s a

Dibujamos adem s del campo de SLP los campos de las componentes de la velocidad zonal y a meridional del viento, en una vista estereogr ca polar. Considerar que los campos U/V est s sacaa a 30

dos de cheros 4D (T,Z,, ). Para que el resultado no salga lleno de vectores, subsampleamos los vectores uno cada dos.
grads -pb << EOG sdfopen /home/jsaenz/meteoclimadata/surface/slp.mon.mean.nc sdfopen /home/jsaenz/meteoclimadata/pressure/uwnd.mon.mean.nc sdfopen /home/jsaenz/meteoclimadata/pressure/vwnd.mon.mean.nc set lat 0 90 set lon -180 180 set mproj nps set gxout shaded set grads off d ave(slp,t=4,t=659,12) set gxout vector set grads off d ave(uwnd.2(z=1),t=4,t=659,12);ave(vwnd.3(z=1),t=4,t=659,12) draw title SLP Abril enable print slp-abril.gm print disable print EOG gxeps -c slp-abril.gm rm slp-abril.gm epstopdf slp-abril.eps grads -pb << EOG sdfopen /home/jsaenz/meteoclimadata/surface/slp.mon.mean.nc sdfopen /home/jsaenz/meteoclimadata/pressure/uwnd.mon.mean.nc sdfopen /home/jsaenz/meteoclimadata/pressure/vwnd.mon.mean.nc set lat 0 90 set lon -180 180 set mproj nps set gxout shaded set grads off d ave(slp,t=4,t=659,12) set gxout vector set grads off d skip(ave(uwnd.2(z=1),t=4,t=659,12),2,2);ave(vwnd.3(z=1),t=4,t=659,12) draw title SLP Abril enable print slp-abril-2.gm print disable print EOG gxeps -c slp-abril-2.gm rm slp-abril-2.gm

31

epstopdf slp-abril-2.eps

6.2.3.

Uso de dimensiones para calcular las medias

En este caso nos interesa hacer una media zonal. GrADS solamente dibuja datos 2-D, y por defecto ja un instante de tiempo y un nivel vertical en el caso de datos 4D, as que hay que seleccionar la manera de especicarle en qu dimensiones tiene que coger la media zonal. e
grads -pb << EOF sdfopen /home/jsaenz/meteoclimadata/pressure/air.mon.mean.nc sdfopen /home/jsaenz/meteoclimadata/pressure/uwnd.mon.mean.nc set lat -90 90 set z 1 11 set lon 1 set gxout shaded set grads off d ave(ave(air,lon=-100,lon=10),t=4,t=659,12) run cbar set gxout contour set grads off d ave(ave(uwnd.2,lon=-100,lon=10),t=4,t=659,12)

draw title Media zonal Abril enable print mediazonal.gm print disable print quit EOF gxeps -c mediazonal.gm epstopdf mediazonal.eps

32

rm *.gm

6.2.4.

Diagramas de H vmoller o

En este caso empleamos un diagrama llamado de H vmoller para identicar la evoluci n temo o poral de las anomalas de temperatura oce nica que aparecen durante los eventos El Ni o. a n
grads -pb <<EOF sdfopen /home/jsaenz/meteoclimadata/reynolds/sstanom_long.nc set lat 0 set lon 110 300 set time 1sep1980 31jul1985 set gxout shaded set grads off d ave(sstanom,lat=-10,lat=10) run cbarn

33

draw title ENSO 1983 enable print enso1983.gm print disable print quit EOF gxeps enso1983.gm rm *.gm epstopdf enso1983.eps

34

6.2.5.

Realizaci n de c lculos sencillos o a

En este caso vamos a comparar el espesor observado entre las medias de abril de la altura geopotencial correspondiente a las capas de 500 y 700 hPa con el que se obtendra de la aplicaci n o de la ecuaci n hipsom trica: o e Pb Rd T log . Z = g Pt
grads -pb << EOF sdfopen /home/jsaenz/meteoclimadata/pressure/hgt.mon.mean.nc z500 = ave(hgt(z=6),t=4,t=659,12) z700 = ave(hgt(z=4),t=4,t=659,12) dzobs = z500-z700 set lat 0 90 set mproj nps set gxout shaded set grads off d z500 draw title Z500 (Abril) run cbar enable print z500abril.gm print disable print c set grads off d z700 draw title Z700 (Abril) run cbar enable print z700abril.gm print disable print c set gxout shaded set grads off d dzobs set gxout contour set grads off d dzobs draw title Espesor Observado Z500-Z700 (Abril) run cbarn enable print dzabril.gm print disable print c sdfopen /home/jsaenz/meteoclimadata/pressure/air.mon.mean.nc Tempave=ave(air.2(z=5),t=4,t=659,12) dzteor=(Tempave+273.15)*287/9.81*log(7./5.) set gxout shaded

35

set grads off d dzobs run cbarn set gxout contour set grads off d dzteor draw title Espesor Teorico Z500-Z700 enable print dzabril2.gm print disable print c EOF gxeps dzabril.gm gxeps dzabril2.gm epstopdf dzabril2.eps epstopdf dzabril2.eps rm *.gm

36