Introducción a IDL

Leonel GutiérrezInstituto de Astronomía, UNAMleonel@astrosen.unam.mxAgosto de 2009

Sesión 4

.COMPILE  – Compila un programa sin correrlo. 

.GO  – Ejecuta un programa previamente compilado. 

.RUN  – Compila y ejecuta los comandos de IDL de un programa. 

.CONTINUE  – Continúa la ejecución de un programa detenido. 

.TRACE  – Similar a .CONTINUE, pero despliega cada línea de código antes de ejecutarla. 

.RESET_SESSION – Reinicia el estado de una sesión de IDL sin necesidad de que el usuario salga y vuelva a iniciar una sesión de IDL. 

.FULL_RESET_SESSION – Hace todo lo que hace .RESET_SESSION más otras tareas de reset como descargar bibliotecas compartidas. 

.OUT  – Continúa la ejecución hasta que termine la actual rutina. 

.RETURN  – Continúa la ejecución hasta que encuentra un RETURN. 

.RNEW  – Borra las variables de un programa $MAIN$ y ejecuta un .RUN. 

.SKIP   – Pasa por alto los siguientes n enunciados. 

.STEP  – Ejecuta uno o n enunciados a partir de la posición actual. 

.STEPOVER – Ejecuta un solo enunciado si éste no llama a una rutina. 

.EDIT  – Abre los archivos en una ventana de edición del IDLDE. 

Más sobre comandos ejecutivos

Más sobre funciones y subrutinas

Se usan 2 tipos de parámetros: posicionales y ''keywords'' (palabras clave)

Parámetros posicionales: Se identifican por su posición en la lista de argumentos.

Un programa puede llamar a un procedure con todos o con sólo algunos de los parámetros posicionales, pero en el orden correcto.

Los parámetros ''keyword'': Se definen por la sintaxisNombre_del_keyword=nombre_de_la_variable

Parámetros

El programa principal suministra un valor al ''nombre_del_keyword'' que se identifica en el procedure por el ''nombre_de_la_variable''.

PRO TEST_MISQRT, x, OPCION=cual    if (x lt 0) then cual = 1    if (NOT KEYWORD_SET(cual)) then begin        print, 'Calcula la raiz cuadrada de manera normal'        print, 'El valor de la raiz es: ', sqrt(x)    endif else begin

print, 'Calcula la funcion que definimos'print, 'El valor de la raiz es: ', misqrt(x)

    endelseEND

Más sobre funciones y subrutinas

- Es una práctica común usar el mismo nombre para el nombre_del_keyword

que para el nombre_de_la_variable

- Los keywords pueden abreviarse al mínimo número de letras que no causen confusión. La variable asociada no puede abreviarse.

- Transmitiendo keywords. Pasar keywords desconocidos a un procedure puede causar errores. Para pasar keywords no difinidos a procedures de menor nivel, puede usarse el keyword _EXTRA en la lista de parámetros.

Más sobre funciones y subrutinas

Manejo de errores- Normalmente, cuando ocurre un error, IDL detiene la ejecución de un programa y permenece en esa unidad de programa. - Es posible cambiar esto con

ON_ERROR, <N> N = 0 (default) : IDL se detiene y se queda donde estaba. N = 1 : IDL regresa al nivel principal. N = 2 : regresa al nivel del programa que hizo la llamada a

la rutina detenida.

Manejo de errores- Errores de E/S: Los errores de entrada/salida pueden manejarse con

ON_IOERROR, etiqueta Esto ordena un salto a la posición de la etiqueta, en el procedure, evitando que el programa termine. Para informar al usuario, puede usarse

MESSAGE, texto Esto manda a la terminal el texto, junto con el nombre del procedure donde se hace la llamada.- Los errores matemáticos pueden revisarse con FINITE y CHECK_MATH.

Más sobre E/S en archivos (Ver en escribe_binarios.pro)outfile = 'binary.dat'n =  20                        ; tama&o del arreglom = 400                        ; tama&o del arreglo zi = LINDGEN(n, n, n)           ; crea el arreglo iz = DIST(m)                    ; crea el arreglo zb = BYTSCL(z)                  ; crea el arreglo b

HELP, n, m, i, z, bPRINT, 'Tamanio del archivo = ', 4*(1+1+n*n*n+m*m) + m*mOPENW, ounit, outfile, /GET_LUN

    ; abre el archivo de salidaWRITEU, ounit, n, m            ; escribe las dimensionesWRITEU, ounit, i, z, b         ; escribe los arreglosFREE_LUN, ounit                ; cierra el archivo binario

Más sobre E/S en archivos (Ver en lee_binarios.pro)infile = 'binary.dat'           ; archivo de entradaOPENR, iunit, infile, /GET_LUN     ; abre el archivon = 0                              ; crea la variable nm = 0                              ; crea m         READU, iunit, n, m                 ; lee n y mi = LONARR(n, n, n)                ; crea el arreglo iz = FLTARR(m, m)                   ; crea el arreglo zb = BYTARR(m, m)                   ; crea el arreglo bREADU, iunit, i, z, b              ; lee los arreglosFREE_LUN, iunit                    ; cierra el archivoHELP, n, m, i, z, b                ; imprime la infoPRINT, z[0:3,0:3]                  ; imprime parte de z

Variables del sistema- IDL cuenta con un conjunto de variables de sistema. - Pueden leerse y modificarse desde cualquier segmento de programa.- Todas empiezan con el signo ! . Algunas variables útiles son las siguientes:“ ”

Nombre      Tipo       Contenido

!path    String       Todos los directorios donde IDL busca

!pi/!dpi Real/Double   Pi en precisión sencilla y doble

!dtor     float         grados a radianes

!radeg    float         radianes a grados

!prompt    String      El prompt de IDL (puede cambiarlo el usuario)

!err    Long      Número de código del último error encontrado

!error     Long      Número de código del  último mensaje de error

!err_string String      Último mensaje de error

!version    Structure   Inf. del Sistema Op. y de la versión de IDL

!d    Structure     Información específica de los dispositivos

!p    Structure     Información específica de las gráficas

!x,!y,!z    Structures    Información de los ejes de graficación

Variables del sistema- Es posible crear variables de sistema con

DEFSYSV, Nombre, Valor [, Read_Only] [, EXISTS=variable] - Algunas variables:

!d - Estructura con información acerca del dispositivo gráfico de salida!d.n_colors : es el número de colores disponibles en IDL!d.name : nombre del dispositivo!d.window : índice de la ventana actualmente abierta!d.x_ch_size, !d.y_ch_size : ancho y largo del rectángulo que encierra

a los caracteres promedio en unidades de dispositivo!p - Estructura con las variables de graficación

!p.multi : configura las gráficas en una ventana!p.background : índice o valor del color de fondo

(Ver en el IDLHELP system variables)

Variables del sistemaPara revisar los parámetros: Para revisar ciertas condiciones de los argumentos de entrada en un procedure:

keyword_set(nombre_del_keyword) regresa 1 si está definido el nombre_del_keyword; si no, regresa un cero

n_params() regresa el número real de parámetros que se le pasaron al procedure.n_elements(variable)

regresa el número total de elementos de una variablesize(variable)

regresa un vector de enteros largos con información acerca de variable

Estructuras

Una estructura combina varios datos en una unidad lógica.

Los elementos en una estructura con nombre se referencian como estructura.elemento.

Para definir una estructura con nombreestructura={nombre_estructura,elemento_1:definicion_1,

elemento_2:definicion_2,....}

Existen estructuras con nombre y estructuras sin nombre o anónimas.

EstructurasEjemplo de estructura con nombre:IDL> dato ={coord, valores:findgen(4), n:4, etiqueta:"un dato"}IDL> print, "Contenido de la estructura con nombre"IDL> print, dato.valoresIDL> print, dato.nIDL> print, dato.etiquetaIDL> dato1 = {coord}IDL> help ,dato   DATO            STRUCT    = ­> COORD Array[1]IDL> help ,dato1

DATO1           STRUCT    = ­> COORD Array[1]IDL> dato2 = {valores:findgen(4), n:4, etiqueta:"un dato"}IDL> help ,dato

DATO            STRUCT    = ­> <Anonymous> Array[1]

Otro ejemplo, una estructura con toda la información de un archivo fits:IDL> cabecera=bytarr(80,36)IDL> datos=fltarr(1024,1024)IDL> fitsim={fits, header:cabecera, data:datos}

EstructurasDefinición automática. El nombre del archivo donde se define la

estructura, debe tener el mismo nombre de la estructura seguido de ''__DEFINE'' (tiene un doble guión bajo).

PRO mi_dato__DEFINE

;  Definicion de la estructura mi_dato

dato = {MI_DATO, $        nombre      : '',  $        debe        : 0.0, $        domicilio   : '',  $        id          : 0L,  $        socio       : ''}

END

En el archivo mi_dato__define.pro

Estructuras

IDL> kk = {mi_dato}IDL> kk.nombre = 'juan'IDL> kk.debe = 10000IDL> kk.domicilio = 'Av. Central # 10'IDL> kk.id = 234IDL> kk.socio = 'no'IDL> print, kk

{ juan      10000.0 Av. Central #10        234 no}IDL> print, kk.id         234

Al intentar crear una estructura de tipo mi_dato, IDL busca automáticamente un procedure llamado MI_DATO__DEFINE

Un ejemplo de una estructura sin nombre:x = findgen(4)dato = {valores:x, n:n_elements(x), etiqueta:"otro dato"}print, "Contenido de la estructura sin nombre"print, dato.valoresprint, dato.nprint, dato.etiqueta

Estructuras

Estructuras jerárquicas: Son ''estructuras que contienen estructuras''. Por ejemplo:

Para definir una estructura sin nombre se definen directamente los elementos:estructura={elemento_1:definicion_1,

elemento_2:definicion_2,....}

nx   = 20x    = {nombre   : 'Longitud', $        valores  : FLTARR(nx)}

ny   = 25y    = {nombre   : 'Latitud', $        valores  : FLTARR(ny)}

dato = {nombre   : 'Temperatura', $        valores  : FLTARR(nx, ny), $        x        : x, $        y        : y}

HELP, dato,   /str    ; /str (o /structure) despliega laHELP, dato.x, /str    ; información de una variable de HELP, dato.y, /str    ; de tipo estructura

PRINT, dato.nombrePRINT, dato.x.nombrePRINT, dato.y.nombre

Estructuras

EstructurasRecordemos un ejemplo de una sesión anterior

 fname = 'datos_a.txt' nl = 0 junk = "" openr, ifile, fname, /get_lun while not eof(ifile) do begin   readf, ifile, junk   nl++ endwhile point_lun,ifile,0 record = {a:0.0, b:0.0, c:0.0} datos = replicate(record, nl) readf, ifile, datos free_lun, ifile print, datos[0:5].aend

Archivo con el programa “lee_datos2.pro”

;la estructura está;formada por tres números ;reales de precisión simple

EstructurasUna estructura puede ser tan compleja como ésta:

table = {nrows: Nlines, a: FLTARR(Nlines), I: FLTARR(Nlines), $     I_err: FLTARR(Nlines), ell: FLTARR(Nlines), $     ell_err: FLTARR(Nlines), pa: FLTARR(Nlines), $     pa_err: FLTARR(Nlines), x0: FLTARR(Nlines), $     x0_err: FLTARR(Nlines), y0: FLTARR(Nlines), $     y0_err: FLTARR(Nlines), I_grad: FLTARR(Nlines), $     I_grad_err: FLTARR(Nlines), mag: FLTARR(Nlines), $     mag_merr: FLTARR(Nlines), mag_perr: FLTARR(Nlines), $     flux_ell: FLTARR(Nlines), flux_circ: FLTARR(Nlines), $     A3: FLTARR(Nlines), A3_err: FLTARR(Nlines), $     B3: FLTARR(Nlines), B3_err: FLTARR(Nlines), $     A4: FLTARR(Nlines), A4_err: FLTARR(Nlines), $     B4: FLTARR(Nlines), B4_err: FLTARR(Nlines), $     stop: INTARR(Nlines)}

EstructurasUn ejemplo de su uso puede verse en el programa ''lee_ell.pro'':   Pro  lee_ell, nombre      OPENR,unit,nombre,/GET_LUN      Nrows = 0      WHILE NOT EOF(unit) DO BEGIN         READF,unit,junk         Nrows = Nrows + 1      ENDWHILE

      Nlines = (Nrows ­ 21)/5      data_block8 = FLTARR(8, Nlines)      data_block9 = FLTARR(9, Nlines)      data_block10 = FLTARR(10, Nlines)      all_data = FLTARR(40, Nlines)

      POINT_LUN,unit,0      READF,unit,junk

Estructuras      FOR I = 0, 4 DO BEGIN         FOR J = 0, 3 DO READF,unit,junk         CASE I OF            0: BEGIN

          READF,unit,data_block9      all_data(0, 0) = data_block9(1:8, *)

            END            1: BEGIN

          READF,unit,data_block9          all_data(8, 0) = data_block9(1:8, *)

            END            2: BEGIN

          READF,unit,data_block8              all_data(16, 0) = data_block8(1:7, *)            END            3: BEGIN

          READF,unit,data_block9              all_data(23, 0) = data_block9(1:8, *)            END            4: BEGIN

          READF,unit,data_block10          all_data(31, 0) = data_block10(1:9, *)

            END         ENDCASE      ENDFOR

Estructuras      CLOSE,unit      FREE_LUN,unit

      reordered = SORT(all_data(0, *))            ; Etiquetas de L. Gutierrez

      table.a = all_data(0, reordered) * ArcsecPerPix ; SMA pixel      table.I = all_data(1, reordered)                ; INTENS      table.I_err = all_data(2, reordered)            ; INT_ERR       table.ell = all_data(5, reordered)              ; ELLIP      table.ell_err = all_data(6, reordered)          ; ELLIP_ERR      table.pa = all_data(7, reordered)               ; PA (degrees)      table.pa_err = all_data(8, reordered)           ; PA_ERR      table.x0 = all_data(9, reordered)               ; XO (pixel)      table.x0_err = all_data(10, reordered)          ; XO_ERR      table.y0 = all_data(11, reordered)              ; YO (pixel)      table.y0_err = all_data(12, reordered)          ; YO_ERR      table.I_grad = all_data(13, reordered)          ; GRAD      table.I_grad_err = all_data(14, reordered)      ; GRAD_ERR       .      .      .(ver el archivo lee_ell.pro y ejecutarlo con     lee_ell, 'el_n3675gsssfix.txt', titulo='NGC 3675')

Fin de la sesión 4