El paréntesis: Instalación de STSDAS y TABLES en linux

Estimados,

Sé que muchas personas han tenido problemas instalando los packages STSDAS y TABLES en sus computadores, asi que he preparado un pequeño manual para que puedan instalarlo de manera fácil y directa.

Hay dos métodos. El método Python (fácil y simple) y el método "un poco más largo". Si no le resulta uno, pruebe con el otro, aunque recomiendo el primero por que es más limpio. Ámbos métodos parten de una base común que es la que voy a describir ahora.

• Parte 1. La base común
  
  Como mencioné, ámbos métodos parten de la misma base, que es lo básico de lo básico en la instalación:
  
  1.- Debemos crear un directorio en donde instalemos los packages externos. Para ello hacemos en consola (y asumiendo todo el rato que pueden ser super-users con "sudo -s"):
  
  $ cd /iraf
  $ mkdir extern
  $ cd extern
  $ mkdir tables
  $ mkdir stsdas
  
  Con ello, hemos creado la carpeta extern (donde irán nuestro packages) y dentro de ésta, creamos dos carpetas: tables y stsdas, que serán las carpetas donde instalaremos los packages.
  
  2.- El siguiente paso es descargar, de la página oficial de STSDAS (http://www.stsci.edu/resources/software_hardware/stsdas/download) y en donde ustedes deseen (en mi caso, se descargan en /home/nestor/Descargas) los archivos comprimidos necesarios para STSDAS y TABLES que son dos: el archivo fuente (source) y el binario, que dependerá de su distribución (asumiremos linux). Los links son:
  
  - TABLES: [SOURCE] [BINARIO (REDHAT)]
  - STSDAS: [SOURCE] [BINARIO (REDHAT)]
  
  3.- Ahora, necesitamos descomprimir dichos archivos en las carpetas correspondientes. Para ello, primero ingresamos a la carpeta tables, descomprimimos el source y luego el binario dentro de la carpeta bin.linux (asumiré, como dije, que mis archivos se descargaron en /home/nestor/Descargas). Primero lo hacemos con TABLES:
  
  $ cd /iraf/extern/tables
  $ gunzip /home/nestor/Descargas/tables3.12.tar.gz
  $ tar -xvf /home/nestor/Descargas/tables3.12.tar
  $ cd bin.linux
  $ gunzip /home/nestor/Descargas/tables3.12.bin.redhat.tar.gz
  $ tar -xvf /home/nestor/Descargas/tables3.12.bin.redhat.tar
  
  Y luego con STSDAS:
  
  $ cd /iraf/extern/stsdas
  $ gunzip /home/nestor/Descargas/stsdas3.12.tar.gz
  $ tar -xvf /home/nestor/Descargas/stsdas3.12.tar
  $ cd bin.linux
  $ gunzip /home/nestor/Descargas/stsdas3.12.bin.redhat.tar.gz
  $ tar -xvf /home/nestor/Descargas/stsdas3.12.bin.redhat.tar
  
  Ojo: Si no vas a usar el método que usa Python para instalar STSDAS, también debes copiar los binarios (los archivos .bin.redhat) en la carpeta bin.redhat, de la misma manera que lo hiciste con bin.linux, para TABLES y para STSDAS.
  
  4.- Ahora necesitamos modificar el archivo principal de IRAF para "avisarle dónde" guardamos los packages. Para ello, debemos buscar el archivo extern.pkg:
  
  $ locate extern.pkg
  
  En mi caso, el archivo está en /iraf/iraf/unix/hlib/extern.pkg. Debemos editar dicho archivo, lo que lo hacemos con nuestro editor favorito (en mi caso Kate):
  
  $ kate /iraf/iraf/unix/hlib/extern.pkg
  
  Allí, nuestro archivo debiése verse así:
  
  reset noao =iraf$noao/
  task noao.pkg =noao$noao.cl
  
  reset helpdb ="lib$helpdb.mip\
  ,noao$lib/helpdb.mip\
  "
  keep
  
  Y debiése quedar así:
  
  reset noao = iraf$noao/
  task noao.pkg = noao$noao.cl
  
  reset tables = /iraf/extern/tables/
  task tables.pkg = tables$tables.cl
  reset stsdas = /iraf/extern/stsdas/
  task stsdas.pkg = stsdas$stsdas.cl
  
  reset helpdb ="lib$helpdb.mip\
  ,noao$lib/helpdb.mip\
  ,tables$lib/helpdb.mip\
  ,stsdas$lib/helpdb.mip\
  "
  keep
  
  Una vez hecho esto, estamos listos para entrar al paso final de la instalación de TABLES y STSDAS (este último NECESITA tables para ser instalado).
  
  
• Parte 2 (Primer método): El método "a lo Python"
  
  Si poseemos Python, la instalación de TABLES y STSDAS será directa y limpia. Basta con ir a la carpeta de stsdas y correr un código que instalará todo de una vez:
  
  $ cd /iraf/extern/stsdas
  $ python python/compileall.py ./python
  $ python python/compileall.py ./python*
  
  ¡Y listo! A saltarse al Paso 3 (para testear que está todo bien instalado).
  
  
• Parte 2 (Segundo método): El método "un poco más largo"
  
  Si no poseemos Python (¡brfs para ti!), deberemos instalar todo "a la mala". Para ello, debemos buscar primero el archivo .cshrc en nuestra carpeta de iraf:
  
  $ locate .cshrc
  
  El mío está en /iraf/iraf/local/.cshrc. Ahora, debemos editar dicho archivo:
  
  $ kate /iraf/iraf/local/.cshrc
  
  Y debiésemos tener lo siguiente en nuestro código (si hay algo que no está, ¡agrégalo!):
  
  setenv iraf /iraf/iraf/
  setenv IRAFARCH redhat
  sourcce $iraf/unix/hlib/irafuser.csh
  
  Una vez hecho esto, instalamos tables primero (recuerda haber metido los archivos que pusiste en bin.linux en bin.redhat al final del Paso 1). Para ello debemos poder entrar a ecl desde xgterm desde la carpeta tables:
  
  $ cd /iraf/extern/tables
  $ mkiraf
  
  Escogemos xgterm y luego seguimos:
  
  $ xgterm
  # ecl
  # mkpkg -p tables
  
  Eso debiése instalar tables. Luego hacemos lo mismo para STSDAS:
  
  $ cd /iraf/extern/stsdas
  $ mkiraf
  
  Escogemos xgterm y luego seguimos:
  
  $ xgterm
  # ecl
  # mkpkg -p stsdas
  
  ¡Y listo! Eso debiése instalar TABLES y STSDAS. Ahora...¡probemos que todo este bien instalado!
  
  
• Paso 3: La prueba de fuego de la instalación de TABLES y STSDAS
  
  Si todo salió bien, esto debiése ser un trámite. Si no, revisa los pasos anteriores o pregunta acá en el blog :). Primero, desde cualquier carpeta que no sea /iraf/extern/tables o /iraf/extern/stsdas ingresa a ecl (mkiraf -> xgterm -> ecl). Ahora escribe:
  
  ecl> stsdas
  stsdas> iminfo dev$pix
  
  Si salen datos en una tabla, todo está bien instalado: ¡Felicitaciones! Ya tienes STSDAS en tu computador.
  

Espero sea de ayuda y cualquier duda/problema, ¡posteenlo! Esa es la idea del blog.

Fuentes: STSDAS Installation Guide, The Step by Step IRAF Installation y The IRAF Official Forum.

Instalación y uso básico de Python

Estimadísimos,

Redacté un manual de uso básico (¡bien básico!) de Python, junto con una pequeña guía de instalación aquí: [~~ LINK ~~]. No incluí manipulación de objetos, pero prometo hacerlo en un futuro.

¡Espero les sea útil!

¿Escribir datos? ¡Writecol lo hace por ti!

Tal como se lee, ¿tienes un montón de datos en vectores que quieres escribir de manera rápida con Python? Es hiper simple con este código que encontré: [~~Link~~] (si no sabes como agregar códigos nuevos a Python, revisa el siguiente post: http://astropytheando.blogspot.com/2010/09/leer-datos-en-python-como-usar-readcol.html).

Un ejemplo del uso de este simple código, en donde guardamos los dos arrays "a" y "b", le ponemos "nombres" a las columnas y llamamos al archivo "Archivo.dat":

from numpy import *
from writecol import *
a=array([0,2,2,5,7,8,4])
b=array([233,333,222,111,787,444,888])
titulo=['#Columna A','Columna B']
writecol('Archivo.dat',a,b,title=titulo)

¿El resultado? Un archivo como el siguiente:

#Columna A   Columna B
0   233
2   333
2   222
5   111
7   787
8   444
4   888

¡Choro!, ¿no? Bueno, bonito...y barato (¡gratis, IDL!)

Leer datos en Python: Como usar readcol, bajarlo, instalarlo, etc.

En realidad no ando con mucho tiempo, pero es un tip digno y rápido de compartir. En IDL, existía un lector de datos en columnas llamado readcol que yo encontraba muy útil, y bueno, me encontré con la sorpresa de que en Python también existe. El código lo pueden descargar acá: [~~Link~~]

¿Que cómo se "instala"? Fue mi misma duda. Primero hay que saber que carpetas lee Python antes de ejecutar los códigos. Para ello, en python hacemos:

>>> import sys
>>> print sys.path

Python lee estas carpetas antes de ejecutar algún código. El paso siguiente es bajar el código que puse más arriba (copiar y pegar el código), ponerlo en un archivo llamado "readcol.py" y posicionar ese archivo en alguna de las carpetas que aparecieron anteriormente (¡cualquiera sirve!). Ésto es como "instalar" el código en nuestro computador: Así de fácil es con Python.

Para usar la herramienta que ya "instalamos" en nuestro computador en nuestro código, simplemente agregamos al principio del mismo:

from readcol import *

Y listo. Supongamos que queremos leer las tres columnas de un archivo en la carpeta en la que estamos que se llama archivo.dat, y queremos pasar los datos a las variables X, Y, t. Para ello escribimos en nuestro código, una vez importado readcol:

X,Y,t=readcol('archivo.dat',twod=False)

¡Y listo! El "twod=False" es por que inicialmente estaba diseñado para leer solo dos columnas, por lo que se hacía "X,Y=readcol("archivo.dat")" simplemente. Pero cuando hay más "dimensiones" en las columnas, debemos agregar eso :). En realidad hay más formas de usarlo, y en el mismo archivo las pueden encontrar: ¡Encuentren la más cómoda para sus necesidades!

PD: Los arrays que nos entrega readcol son de NUMPY, no de NUMARRAY (por tanto cosas como X.pop(numero) ó X.append(otronumero) no funcionan...pero NUMPY siempre tiene solución para todo, léase: "Los análogos a append y pop".

Los análogos a list.pop y .list.append en NumPy

La verdad venía buscando algo así hace rato, por que me gusta ocupar el comando readcol (léase cómo usar readcol en Python) que es súper simple de usar en Python para leer datos, pero que agraciadamente (y ya verán por que) nos entrega arrays estilo NUMPY, y no NUMARRAY. En Python (bueno, NUMARRAY), uno al crear un array llamado "lista", por ejemplo que tenía los elementos [0,1,2,3,4], uno podía hacer:

>>> lista.pop(4)

Y eso eliminaba el cuarto elemento de mi array. Pasaba lo mismo con:

lista.append(numero)

Donde uno agregaba el valor "numero" al último elemento del array. En Numpy, los análogos a esto son mucho más generales y poderosos. El análogo a pop vendría siendo el comando delete. Con Numpy importado, si tenemos la misma lista pero creada "al estilo Numpy", o sea:

>>> from numpy import *
>>> lista=array([0,1,2,3,4,5,6,7,8,9,10])

Para ocupar el comando delete, por ejemplo, para borrar el elemento 2, 3 y 4 de mi array hago:

>>> lista = delete(lista,[2,3,4])

Y al imprimir mi lista en la línea de comandos, me queda:

>>> print lista
[0 1 5 6 7 8 9 10]

Ya, ok, ok. Pero...¡append si que era útil! Pues bien, efectivamente existe el comando append en Numpy. Para hacer lo mismo a mi lista a la que le borré los elementos de más arriba, y agregrale al final los valores 0.001 y 0.005, hacemos:

>>> lista=append(lista,[0.001,0.005])

Y al ver mis valores, obtengo:

>>> print lista
[0e0 1e0 5e0 6e0 7e0 8e0 9e0 10e0 1e-3 5e-3]

¡No se asusten! Es lo mismo, solo que nos convirtió todos nuestros datos a float :). Pero...supongamos que tenemos dos listas, lista1 y lista2 y los queremos unir...¿cómo lo hacemos más eficientemente? Ocupamos el comando hstack:

>>> lista=hstack([lista1,lista2])

¡Y listo! Ah...¿cuál es la diferencia? Que aquí jugué con matrices de rango 1 (vectores n-dimensionales). Lo que puse más arriba tiene muchas mejores aplicaciones a matrices: ¡Jueguen!

Referencias: The Official Numpy Example List