Programa para el clculo de los coeficientes de un modelo de apuntado para un telescopio.

Leonel Gutirrez

Octubre, 2005

1. Introduccin
Generalmente, cuando se instala un telescopio, su alineacin no es perfecta. Esta falta de alineacin se traduce siempre en errores, tanto en el apuntado como en el seguimiento de los objetos estelares con el telescopio. Por tanto, en un telescopio profesional es necesario alinearlo de la mejor manera posible, moviendo la montura del telescopio hasta que los errores se reducen al mnimo. Esta tarea se ha realizado ya en los telescopios del Observatorio Astronmico Nacional en San Pedro Mrtir. Sin embargo, an en esas circunstancias, quedan errores residuales muy difciles de corregir mecnicamente, por lo que es necesario contar con un modelo que permita corregir previamente las coordenadas para conseguir un ptimo apuntado del telescopio. Aunque aqu nos referiremos slo a los telescopios con montura ecuatorial, la idea tambin se aplica a otros tipos de monturas. Actualmente, los telescopios del Observatorio Astronmico Nacional en San Pedro Mrtir cuentan con un modelo que hace un ajuste en base a polinomios. Sin embargo, debido a diversos factores como el hecho de que la distribucin de cargas del telescopio no sea constante en el tiempo, pues estn sujetos a cambios de instrumentos, es necesario recalcular con cierta frecuencia los coeficientes del modelo para optimizar la precisin de apuntado de telescopio. Pero esto requiere de un mtodo de fcil implementacin que permita el clculo de los coeficientes por parte del personal tcnico del Observatorio, a fin de contar siempre con el mejor modelo de apuntado. En este trabajo se describe un modelo de ajuste trigonomtrico y, se propone un programa con el que se ha conseguido encontrar los coeficientes para la correccin de los errores de alineacin al polo, falta de perpendicularidad de los ejes, flexiones mecnicas y falta de alineacin del eje ptico. El programa est escrito en Fortran y hace uso de las nuevas caractersticas del Fortran 95, lo que permite hacer una gran cantidad de clculos de manera muy simple. Existe tambin una versin para IDL y en breve estar lista una versin del programa en Fortran77. El caso que se presenta como ejemplo usa datos que

corresponden al telescopio de 1 m de dimetro del OAN en Tonantzintla, pero el mtodo puede aplicarse directamente a cualquier tipo de telescopios con montura ecuatorial. Aplicando el modelo de correcciones a una base de datos de errores de apuntado, los errores rms se han reducido en Declinacin de 49.8 a 8.9 y en ngulo Horario de 99.7 a 30.1.

2. Entendiendo el problema
Un objeto en el cielo se identifica por sus coordenadas: ascensin recta y declinacin (AR/Dec o /). Las declinaciones se miden hacia el norte y hacia el sur del ecuador celeste, mientras que la ascensin recta se mide hacia el este del equinoccio (la interseccin entre el ecuador celeste y la eclptica, siendo esta ltima el plano de la rbita de la Tierra alrededor del Sol). Pero, conocer AR y Dec no es el final de la historia. Hay una serie de correcciones y transformaciones astronmicas para hacer antes de estar listos para apuntar el telescopio. Luego, es necesario traducir estas coordenadas a otras coordenadas que sirvan para mover el telescopio. Pero en un telescopio ecuatorial (ver figuras 1, 2 y 3) la situacin es, en teora, simple, ya que si el eje polar del telescopio es paralelo al eje polar de la Tierra, la declinacin del telescopio coincide con la declinacin celeste; el otro eje del telescopio, denominado ngulo horario (AH) y medido hacia el este y el oeste del meridiano, se relaciona con la ascensin recta mediante la ecuacin AR = TS AH, donde TS es el tiempo sideral local (el tiempo sideral local corre un poco mas rpido que el tiempo regular, de tal manera que se adelanta casi 4 minutos diarios).

Figura 1. Dos tipos de monturas ecuatoriales simtricas.

Figura 2. Dos tipos de monturas ecuatoriales asimticas.

Pero el problema no ha terminado. Aunque ya tenemos las coordenadas del telescopio y estamos listos para moverlo, hemos olvidado que vivimos en un planeta que gira y se balancea, que vemos a travs de una atmsfera y que el telescopio no es una mquina perfecta. Todos estos factores han de tomarse en cuenta antes de apuntar el telescopio. La secuencia de clculos y ajustes que debemos hacer se muestra en la figura 4.

Figura 3. Telescopio de 2.1m de SPM. Su montura es ecuatorial de yugo (simtrica).

Los tres pasos principales son: pasar de coordenadas medias a aparentes, de aparentes a observadas y de observadas a instrumentales. El primer paso corrige el hecho de que el eje de la Tierra y, por tanto, el ecuador celeste estn en constante movimiento debido a la precesin y a

la nutacin, as como el hecho de que nuestro movimiento alrededor del Sol hace que las estrellas parezcan desplazarse debido a la aberracin anual. La transformacin de aparentes a observadas se debe a la rotacin de la Tierra, a la ubicacin geogrfica del telescopio y a la refraccin atmosfrica. El ltimo paso consiste en corregir las imperfecciones instrumentales del telescopio.

Figura 4. Diagrama que muestra la secuencia de las correcciones.

Las primeras trasformaciones se realizan con ecuaciones que se aplican de igual manera en cualquier telescopio y no dependen de la construccin del mismo. Sin embargo, la ltima es una transformacin nica para cada telescopio, pues slo depende de sus propias caractersticas.

La precesin del polo terrestre alrededor del polo de la eclptica, junto con una inclinacin gradual de la eclptica, es la componente de largo plazo de un movimiento complejo causado por los efectos gravitacionales de los miembros del Sistema Solar sobre la Tierra que gira. El periodo de este movimiento es de 26000 aos y produce cambios de hasta 50 segundos de arco por ao en las coordenadas de las estrellas. El cabeceo residual del eje terrestre, que tiene un perodo de 18.6 aos, es la nutacin y afecta el apuntado del telescopio en el orden de los 10 segundos de arco. La aberracin anual es culpable de hasta 20 segundos de error en el apuntado de un telescopio. Luego, dado que el telescopio est en la Tierra y dentro de la atmsfera, es necesario hacer las otras correcciones para lo cual es necesario conocer la latitud, la longitud y altura sobre el nivel del mar del sitio donde est el observatorio, as como la presin y la temperatura ambiente y el tiempo exacto. Los errores que pueden cometerse por el efecto de la refraccin son hasta del orden de 1 minuto de arco para una elevacin de 45 al nivel del mar. Todas estas correcciones proporcionan las coordenadas observadas, que, si todo fuera perfecto, nos permitira ver la estrella perfectamente centrada en el telescopio. Pero el telescopio es real y, por tanto, sus codificadores pueden tener un ligero desplazamiento en sus lecturas, puede haber un ligero juego en los engranes (backlash), sus ejes pueden no ser perfectamente perpendiculares y el eje polar del telescopio puede no estar apuntando exactamente al polo. Corregir fsicamente estas imperfecciones puede ser una tarea larga y costosa, por lo que en ocasiones es mejor aceptarlas y tenerlas en cuenta al calcular las coordenadas del objeto.

3. El modelo de apuntado
En una montura ecuatorial, estas imperfecciones causan un efecto que puede modelarse mediante seis trminos puramente geomtricos, complementados con tres debidos a flexiones (Wallace y Tritton,1975; Trueblood y Genet, 1998; Wallace, 2001). En la tabla 1 se muestran estos trminos. Los trminos HI y DI son simplemente errores de inicializacin en las lecturas de las coordenadas instrumentales y pueden calcularse con un apuntado inicial del telescopio. El trmino CO describe qu tan precisa es la alineacin entre el eje mecnico del telescopio y el eje ptico y si el instrumento de deteccin est bien alineado (la componente que afecta a declinacin no depende del ngulo, por lo que queda integrada en DI). El trmino NP depende de qu tan lejos del ngulo recto est el eje de declinacin con respecto al eje polar.
Trmino HI DI CO NP Descripcin Error constante de posicin Error constante de posicin Error de colimacin y el eje polar no perpendiculares Efecto en elevacin de la no coincidencia con el polo Efecto perpendicular a PV Flexin del tubo CO*sec NP*tan PV*senh*tan -PH*cosh*tan FT*cos*senh*sen PV*cosh h HI DI

PV

PH FT

PH*senh FT*(cos*cosh*sensen*cos) FY*cosh

FY FD

Flexin del yugo Flexin del eje de declinacin -FD*(cos*cosh+ sen*tan)

Tabla 1. Trminos que afectan en una montura ecuatorial. h y son el ngulo horario y la declinacin y es la latitud del observatorio.

Los trminos PH y PV describen qu tan apartado est el eje polar del eje verdadero en la direccin horizontal en el caso de PH y en la vertical para PV. FT describe cunto cae el telescopio al acercarse ms a una posicin horizontal. FY es la flexin del yugo (o tenedor) y FD es un trmino de flexiones para el eje de declinacin, que slo se aplica en el caso de los telescopios como los de montura alemana, en la que el eje de declinacin no est soportado en ambos extremos. Adems de estos trminos, generalmente existen trminos menores que presentan un comportamiento peridico, causados por defectos de maquinado y de alineacin de los diferentes ejes y acoplamientos, que generalmente son de magnitud menor. Estos no se incluyen en el modelo aqu descrito. En la Tabla 1, cada uno de los coeficientes es en general un ngulo pequeo, usualmente del orden de segundos de arco. Las frmulas para corregir cada uno de los ejes estn dadas por la suma de los elementos en sus respectivas columnas. As, despreciando el trmino FD, las frmulas de correccin para el modelo de apuntado son:
h = HI + CO*sec + NP*tan - PH*cosh*tan + PV*senh*tan + FT*cos*senh*sen = DI + PH*senh + (PV+FY)*cosh + FT*(cos*cosh*sen-sen*cos)

Aplicando este modelo puede mejorarse notablemente el apuntado del telescopio.

4. Cmo encontrar los coeficientes?

Encontrar los coeficientes del modelo no es una tarea fcil (excepto por HI y DI). Adems, los coeficientes varan ligeramente con el tiempo y un modelo no puede durar toda la vida: la fatiga de los elementos del telescopio y el esquema instrumental provocarn ligeras variaciones en los coeficientes de flexin, el desplazamiento del eje ptico durante los procesos de mantenimiento provocarn una variacin en el coeficiente CO y los asentamientos del suelo provocarn variaciones en la alineacin del eje polar del telescopio. Esto hace que deban calcularse los coeficientes con cierta periodicidad. Por esta razn, se ha creado el programa encuentra_modelo. Este programa ha sido escrito en Fortran, usando las nuevas implementaciones incorporadas en el Fortran 95 y se debe usar en ambiente Linux. Tambin es importante que se encuentre instalada una versin del Gnuplot. Existe tambin una versin para IDL. Para usarlo, es necesario apuntar el telescopio a diferentes estrellas brillantes en el cielo, cuyas coordenadas observadas hayan sido previamente calculadas. Es importante incluir diferentes posiciones en el cielo, anotando la correccin manual que haya tenido que hacerse, tanto en ngulo horario como en declinacin. Los datos deben tabularse en un archivo de texto de la siguiente manera: AH dAH Dec dDec

donde AH y Dec son el ngulo horario (en horas con respecto al meridiano) y la declinacin (en grados) de las coordenadas calculadas del objeto y dAH y dDec son las correcciones que tuvieron que hacerse para centrar el objeto en el telescopio, dadas en segundos de arco. Por ejemplo: -2.473 -1.799
(AH)

-33 42
(dAH)

-16.686 22.515
(Dec)

-50.2 16.0
(dDec)

Es importante incluir el mayor nmero de puntos en la muestra para garantizar un mejor ajuste del modelo. Se recomiendan unos 40 puntos, para tener del orden de 10 en cada cuadrante del cielo.

5. Descripcin del programa

A este texto se anexa en el Apndice A un listado del programa en Fortran y en el Apndice B el correspondiente listado de la versin para IDL. El programa escrito en Fortran funciona de la siguiente manera: a) Busca el archivo con los datos. El programa solicita al usuario que proporcione el nombre del archivo (el que se ha usado para hacer las pruebas se llama epos.txt). b) Solicita al usuario la latitud del lugar en grados. c) Cuenta cuntas lneas no vacas tiene el archivo, a fin de alojar en memoria un array suficientemente grande para contener los datos. Los elementos de este array son de tipo derivado y contienen cuatro elementos de tipo real: AH, Dec, dAH y dDec. d) Grafica los errores dDec contra dAH para que el usuario tenga una idea de la magnitud de los errores. e) Calcula el trmino cos*cosh*sen-sen*cos y ajusta la recta tomando como eje vertical a dDec. La pendiente encontrada corresponde al termino FT. Presenta al usuario los datos (pendiente, ordenada al origen y correlacin del ajuste), quien puede aceptar o no la correccin. f) Una vez corregidos los errores por este trmino, se calcula el trmino cosh y repite el proceso anterior. Esto da como resultado la suma de los trminos PV y FY. Nuevamente, pregunta al usuario si acepta la correccin. g) Corrige los errores, si as lo ha decidido el usuario, y calcula el trmino senh. Al repetir el proceso se tiene el trmino PH. De esta manera se han encontrado ya los coeficientes que corrigen declinacin. h) Grafica, llamando al gnuplot, los datos mostrando cmo estaban distribuidos los datos durante los ajustes.

i) Incorpora los trminos calculados (FT y PH) y corrige los errores en ngulo horario. Revisa si existe algn posible backlash en el mecanismo y lo corrige. j) Calcula el trmino senh*tan y ajusta de nuevo una recta, tomando ahora como eje vertical a dAH. La pendiente del ajuste es ahora PV. Esto permite discriminar ya tambin el trmino FY, pues slo se conoca la suma PV+FY. k) Si el usuario acepta la correccin, se corrigen los errores y se calcula ahora el trmino tan. Esto permite encontrar el trmino NP. l) Finalmente, calcula el trmino sec y encuentra el trmino CO. m) Grafica ahora los datos de ngulo horario mostrando cmo estaban distribuidos durante los ajustes. Tambin muestra los errores corregidos graficando nuevamente dDec contra dAH y presenta los valores de los coeficientes encontrados. El programa escrito para IDL funciona de manera parecida, con algunas pequeas variantes: a) El programa recibe como argumentos lel nombre del archive con los datos, la latitud del observatorio y un arreglo de unos y ceros que indican qu correcciones se harn. Por ejemplo:
ENCUENTRA_MODELO, archivo="epos.txt", latitud=19.5, corrige=[1,1,1,0,1,0,1]

indica que se harn las correcciones correspondientes a PH, PV, FT, NP y BL y que no se aplicarn las correcciones por el trmino combinado PV_FY ni la de colimacin ptica. El orden es: PH, PV, FT, PV_FY, NP, CO, BL La ausencia de este arreglo en el argumento har que se calculen todas las correcciones. De hecho, se recomienda habilitar todas las

correcciones en una primera ejecucin y determinar de all los trminos que pueden o deben omitirse. La latitud deber darse en grados. b) Busca el archivo con los datos. c) Grafica los errores dDec contra dAH para que el usuario tenga una idea de la magnitud de los errores. d) Calcula el trmino cos*cosh*sen-sen*cos y ajusta la recta tomando como eje vertical a dDec. La pendiente encontrada corresponde al termino FT. e) Una vez corregidos los errores por este trmino, se calcula el trmino cosh y repite el proceso anterior. Esto da como resultado la suma de los trminos PV y FY. f) Corrige los errores, si as lo ha decidido el usuario con los valores del argumeno, y calcula el trmino senh. Al repetir el proceso se tiene el trmino PH. De esta manera se han encontrado ya los coeficientes que corrigen declinacin. g) Grafica los datos usando las propias utileras de IDL, mostrando cmo estaban distribuidos durante los ajustes. h) Incorpora los trminos calculados (FT y PH) y corrige los errores en ngulo horario. Revisa si existe algn posible backlash en el mecanismo y lo corrige. i) Calcula el trmino senh*tan y ajusta de nuevo una recta, tomando ahora como eje vertical a dAH. La pendiente del ajuste es ahora PV. Esto permite discriminar ya tambin el trmino FY, pues slo se conoca la suma PV+FY. j) Se corrigen los errores y se calcula ahora el trmino tan. Esto permite encontrar el trmino NP. k) Finalmente, calcula el trmino sec y encuentra el trmino CO.

l) Grafica ahora los datos de ngulo horario mostrando cmo estaban distribuidos durante los ajustes. Tambin muestra los errores corregidos graficando nuevamente dDec contra dAH y presenta los valores de los coeficientes encontrados. Los trminos HI y DI encontrados durante este ajuste no deben ser definitivos, ya que dependen del proceso de inicializacin al empezar una sesin de observacin. Estos valores deben recalcularse cada vez que se inicia una sesin de observacin, apuntando una estrella despus de haber aplicado el modelo calculado. El error en este primer apuntado corresponde directamente a los trminos HI y DI. Si se desea, pueden apuntarse varias estrellas y promediar los errores encontrados. Pero este hecho puede obviarse en los telescopios del OAN en SPM, pues el sistema de control de los telescopios calcula estos trminos cuando se corrigen las coordenadas despus del primer apuntado. Los coeficientes encontrados pueden sustituirse ahora en las frmulas de la seccin 3 para hacer las correcciones a las coordenadas. Para obtener mejores resultados de este modelo trigonomtrico, en el caso de los telescopios del OAN en San Pedro Mrtir, se sugiere inhibir el modelo polinomial que actualmente corrige los errores mecnicos de apuntado, calcular los coeficientes del modelo trigonomtrico y, despus de aplicarlo, recalcular el modelo polinomial, pues con este ltimo pueden modelarse los dems errores residuales (errores de los acoplamientos de los codificadores, errores de los engranes, etc.) que prcticamente no cambian con el tiempo.

6. Resultados
Para probar el algoritmo, hemos aplicado el programa a una base de datos con errores de apuntado del telescopio del Observatorio Astronmico Nacional en Tonantzintla y hemos encontrado los siguientes coeficientes para el modelo (en este caso se us descartaron las correcciones para CO y para el trmino combinado PV_FY:

Trmino Offset en AH Offset en Dec Error de colimacin Falta de perpendicularidad Error horizontal en el polo Error horizontal en el polo Flexin del tubo Flexin del yugo Backlash en AH HI DI CO NP PH PV FT FY BL

Valor en segundos de arco 9.328 9.550 0.000 67.520 -17.693 -117.582 137.124 117.582 171.394

Estos valores permiten disminuir el valor rms de los errores desde 99.7 y 49.8 para AH y Dec, respectivamente, hasta 30.1 y 8.9. En las figuras 5, 6, 7 y 8 se reproducen las grficas entregadas por el programa. El cdigo de ambas versiones del programa presentadas aqu se encuentra en la direccin: http://www.astrosen.unam.mx/~leonel/progs/modelo/

Figura 4. Grfica con los errores de Dec y de AH, antes de ser corregidos. Los aparentes 2 grupos de datos se deben al error por juego mecnico (backlash).

Figura 5. Grfica de los errores de la figura 5 despus de ser corregidos. Ntese la escala de los ejes.

Figura 6. Grficas de los errores de Declinacin durante el proceso de correccin.

Figura 7. Grfica de los errores en ngulo Horario durante el proceso de correccin. Ntese el escaln en la primera grfica al pasar por cero en AH debido al backlash.

7. Referencias
1. Wallace, P. T, y Tritton, K. P., 1979, MNRAS, 189, 115. 2. Trueblood, M. y Genet, R. M., Telescope Control, Willman-Bell, Inc., Richmond, Virginia, USA, 1998. 3. Wallace, P., Telescope Pointing, http://www.tpsoft.demon.co.uk/pointing.htm (2001).

Apndice A. Listado del programa en Fortran95

! Listado del programa !******************************************************************************************! ! Programa 'encuentra_modelo' elaborado por Leonel Gutierrez ! ! Este programa lee un archivo con una serie de datos que muestran los errores de ! apuntado de un telescopio con montura ecuatorial y calcula los coeficientes de ! un modelo trigonometrico para corregir dicho apuntado. ! !******************************************************************************************! ! ! Lo que sigue es un modulo con los elementos necesarios para el programa ! Contiene las siguientes funciones y subrutinas ! ! 1) ! Funcion para contar los renglones del archivo ! function cuantas_lineas(archivo) result(cuantas) ! ! 2) ! Subrutina para traer todos los elementos a sus lugares en el arreglo ! subroutine trae_lineas(archivo, arreglo) ! ! 3) ! Subrutina para guardar en un archivo provisional los datos a graficar ! subroutine guarda_lineas(archivo, matriz) ! ! 4) ! Subrutina para ajustar por minimos cuadrados una recta a una distribucion. Calcula ! ! la pendiente, la ordenada al origen y la correlacion ! subroutine ajusta_recta(x, y, m, b, corr) ! ! 5) ! Funcion que calcula el valor rms de un vector. ! function calcula_rms(x) ! ! 6) ! Subrutina que prepara el archivo que se le va a entregar al 'gnuplot' ! subroutine prepara_archivo_de_grafica() ! ! 7) ! Subrutina que agrega las diferentes graficas al archivo que usara el 'gnuplot'. ! ! Podemos poner hasta 4 graficas en una ventana. (El 'gnuplot' permite muchas ! ! mas, pero en este programa nos hemos limitado a 4.) ! subroutine agrega_grafica(x, y, sx, sy, posx, posy, etiqueta, archivo_prov) !

! 8) ! ! ! 9) ! ! !10) ! ! !11) !

! Subrutina que inicia una grafica llamando al 'gnuplot' subroutine inicia_grafica() ! Subrutina que grafica los errores de Declinacion contra los de AH subroutine grafica_errores(etiqueta) ! Subrutina que calcula los coeficientes del modelo usando los errores de Declinacion subroutine encuentra_coeficientes_dec() ! Subrutina que calcula los demas coeficientes del modelo usando los errores de AH subroutine encuentra_coeficientes_ah()

module utilerias ! variables y constantes para usarse en el modulo integer, parameter character(len = 256) integer :: dp = selected_real_kind(8,30) ! La clase de doble precision :: linea ! define una cadena para ir leyendo el archivo :: ioss ! variable para almacenar los errores del READ

! Voy a poner los reales de doble precision para no tener problemas de redondeo ! en las funciones trigonometricas real(kind=dp), parameter :: pi = acos(-1.) real(kind=dp), parameter :: gra_rad = pi/180. ! Factor multiplicativo para convertir ! grados en radianes real(kind=dp), parameter :: horas_rad = gra_rad*15.0 ! Factor multiplicativo para convertir ! horas de cielo en radianes integer :: d1, d2, d3,d4 ! dummies real(kind=dp), dimension(4) :: correlacion ! para guardar las correlaciones real(kind=dp), dimension(4) :: m ! las pendientes real(kind=dp), dimension(4) :: b ! y las ordenadas character(len=10) :: resp ! para los dialogos real(kind=dp) real(kind=dp) real(kind=dp) real(kind=dp) real(kind=dp) real(kind=dp) real(kind=dp) real(kind=dp) :: :: :: :: :: :: :: :: PH PV FT FY NP CO PV_FY DAF = = = = = = = = 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 ! ! ! ! ! ! ! ! ! Error horizontal en el polo Error vertical en el polo Flexiones del tubo Flexiones del yugo Falta de perpendicularidad Colimacion Flexiones del yugo + error vertical en polo Flexiones del eje de declinacion; No se aplica en este caso

real(kind=dp) real(kind=dp) real(kind=dp) real(kind=dp) real(kind=dp) real(kind=dp) ! variables derivadas type coordenadas real(kind=dp) real(kind=dp) real(kind=dp) real(kind=dp) end type coordenadas ! variables globales

:: BL :: HI :: DI :: phi :: senphi :: cosphi

= 0.0 = 0.0 = 0.0 = 19.5*gra_rad

! Error de backlash ! Offset inicial en AH ! Offset inicial en Dec ! La latitud del observatorio ! Esto es el seno de la latitud ! Esto es el coseno de la latitud

:: AH :: Dec :: dAH :: dDec

! Angulo horario del telescopio ! Declinacion ! Error en AH ! Error en Dec

! En este arreglo pongo todos los datos del archivo type(coordenadas), dimension(:), allocatable :: arreglo ! ! ! ! ! ! Esta es una matriz de n x 9 donde pondremos los ejes a graficar; las columnas quedaran asignadas como sigue: 1) para el eje x 2) para los errores antes de corregirse; estos se graficaran en el eje y En las demas columnas se pondran los mismos errores conforme se les vaya aplicando las correcciones :: matriz :: ii ! un indice

real(kind=dp), dimension(:,:), allocatable integer contains

!***************************************************! ! Funcion para contar los renglones no vacios del archivo. Esto permite reservar el numero de lugares ! necesario para los arreglos usados en el programa. Basicamente son 'arreglo' y 'matriz', asi como ! algunos vectores auxiliares dentro de las subrutinas ! function cuantas_lineas(archivo) result(cuantas) character(*), intent(in) :: archivo integer :: cuantas

logical :: existe ! variable para verificar que el archivo existe inquire(FILE = archivo, EXIST = existe) cuantas = 0 if (existe) then open (unit=1,file=archivo,status='old') i = 0 do read(1,'(a)',IOSTAT=ioss) linea if(IOSS == 0) then if(len_trim(linea) > 0) i = i + 1 else exit endif enddo cuantas = i close(1) else print*,"No existe el archivo" end if end function cuantas_lineas !***************************************************! ! Subrutina que lee todos los renglones del archivo de entrada y pone todos los elementos en ! sus lugares correspondientes en el arreglo. ! Subroutine trae_lineas(archivo, arreglo) character(*), intent(in) :: archivo type(coordenadas), dimension(*) :: arreglo logical :: existe ! variable para verificar que el archivo existe

inquire(FILE = archivo, EXIST = existe) if (existe) then open (unit=1,file=archivo,status='old') i = 1 do read(1,'(a)',IOSTAT=ioss) linea if(IOSS == 0) then if(len_trim(linea) > 0) then

read(linea,*), arreglo(i)%AH, arreglo(i)%dAH, & arreglo(i)%Dec, arreglo(i)%dDec i = i + 1 endif else exit endif end do close(1) else print*,"No existe el archivo" end if end Subroutine trae_lineas !***************************************************! ! Esta subrutina guarda la matriz en un archivo provisional para que sea de alli donde tome el 'gnuplot' los ! datos a graficar. El archivo provisional no se borrar al terminar el programa, a fin de que el usuario ! pueda tener los datos como referencia. El archivo para graficar los errores de Declinacion en cada etapa ! de la correccion, quedan guardados en el archivo 'prov.txt'; los de AH quedan en 'prov_ah.txt'; los errores ! ya corregidos por el modelo quedan en 'prov_i.txt'. Al reiniciarse el programa, los archivos se sobreescriben. ! Subroutine guarda_lineas(archivo, matriz) character(*), intent(in) :: archivo real(kind=dp), dimension(:,:), intent(in) :: matriz integer n = size(matriz,1) :: n

open (unit=1,file=archivo,status='replace') i = 1 do write(1,'(9(f10.5,3X))',IOSTAT=ioss) matriz(i,1), matriz(i,2), matriz(i,3), matriz(i,4), & matriz(i,5), matriz(i,6), matriz(i,7), matriz(i,8), matriz(i,9) if(IOSS == 0) then i = i + 1 if (i == n) exit else exit endif end do close(1) end Subroutine guarda_lineas

!***************************************************! ! Esta subrutina ajusta una recta usando el metodo de minimos cuadrados ! subroutine ajusta_recta(x, y, m, b, corr) real(kind = dp), dimension(:), intent(in) :: x real(kind = dp), dimension(:), intent(in) :: y real(kind = dp), intent(out) :: m real(kind = dp), intent(out) :: b real(kind = dp), intent(out) :: corr real, dimension(:), allocatable integer :: n :: va, vb, vc ! vectores auxiliares ! tamanio de x o y

! variables para calcular la estadistica real(kind = dp) :: sumax, sumay, sumaxy, sumax2, & cociente, varx, vary, covxy, Xm, Ym ! Procedemos con los minimos cuadrados canonicos n = size(x) ! Aqui calculamos el tamanio del arreglo ! Reserva n lugares para va, vb y vc

allocate(va(n)) allocate(vb(n)) allocate(vc(n)) sumay sumax va sumax2 va sumaxy cociente b m = = = = = = =

sum(y) ! Suma de todos los elementos en y sum(x) ! Suma de todos los elementos en x x*x sum(va) ! Suma de todas las x^2 x*y sum(va) ! Suma de todas los elementos cruzados n*sumax2 - sumax*sumax ! La ordenada al origen = (sumay*sumax2-sumax*sumaxy)/cociente ! La pendiente = (n*sumaxy-sumax*sumay)/cociente

! Vamos a sacar ahora la correlacion Xm = sumax/n ! La media de x Ym = sumay/n ! La media de y va vb = x - Xm = y - Ym ! Calcula los errores en x ! Calcula los errores en y

vc sumay2 vc sumax2 vc sumaxy varx vary covxy corr

= vb*vb = sum(vc) = va*va = sum(vc) = va*vb = sum(vc) = = = =

! Calcula el vector de los cuadrados de las ! diferencias en y ! Aqui la suma de todo ese vector ! Calcula el vector de los cuadrados de las ! diferencias en x ! Aqui la suma de todo ese vector ! Calcula el vector de los productos cruzados ! Aqui la suma de todo ese vector

deallocate(va) deallocate(vb) deallocate(vc) end subroutine ajusta_recta

sumax2/n ! La varianza en x sumay2/n ! La varianza en y sumaxy/n ! La covarianza covxy/(sqrt(varx*vary)) ! Finalmente ya tenemos el coeficiente de correlacion ! Libera la memoria

!***************************************************! ! Esta funcion calcula el valor rms de un vector. En este caso, se trata de un ! vector de errores ! function calcula_rms(x) result(rms) real(kind = dp), dimension(:), intent(in) :: x real(kind = dp) :: rms real, dimension(:), allocatable integer :: n :: va, vb, vc ! vectores auxiliares ! tamanio de x o y

! variables para calcular la estadistica real(kind = dp) :: sumax, sumax2, varx, Xm, Ym n = size(x) ! Aqui calculamos el tamanio del arreglo ! Reserva n lugares para va

allocate(va(n)) ! Vamos a calcular el RMS sumax = sum(x) Xm = sumax/n va = x - Xm va = va*va

! ! ! ! !

Suma de todos los elementos en x La media de x Calcula los errores en x Calcula el vector de los cuadrados de las diferencias en

sumax2 varx rms

= sum(va) = sumax2/n = sqrt(varx)

! Aqui la suma de todo ese vector ! La varianza en x ! ! Finalmente ya tenemos el coeficiente de correlacion ! Libera la memoria

deallocate(va) end function calcula_rms

!***************************************************! ! Esta subrutina prepara el archivo que luego se le entregara al 'gnuplot' para hacer las ! graficas ! subroutine prepara_archivo_de_grafica() open (unit=3,file="pp.prg",status='replace') write(3,'(A)') "set origin 0,0" write(3,'(A)') "set size 1,1" write(3,'(A)') "set multiplot" close(3) end subroutine prepara_archivo_de_grafica !***************************************************! ! Esta subrutina ordena al sistema que arranque el 'gnuplot' usando el archivo 'pp.prg' ! como archivo de lotes para hacer las graficas ! subroutine inicia_grafica() character(len = 25) :: salida salida = "gnuplot -persist pp.prg" call system(salida) end subroutine inicia_grafica !***************************************************! ! Esta subrutina agrega al archivo 'pp.prg' los mandos necesarios para insertar una grafica en ! la ventana del 'gnuplot' ! subroutine agrega_grafica(x, y, sx, sy, posx, posy, etiqueta, archivo_prov) ! 'x' es el numero de columna que se usara en el eje x; lo mismo con 'y' ! 'sx' es la etiqueta que ira en el eje x; lo mismo con y integer, intent(in) :: x, y character(len = *), intent(in) :: sx, sy ! etiquetas para la grafica integer, intent(in) :: posx, posy ! pueden valer 0 y 1, para ! indicar en que cuadrante se van a poner

! 'archivo_prov' es donde se han puesto los datos a graficar character(len = *), intent(in) :: etiqueta character(len = *), intent(in) :: archivo_prov integer :: mx, my, mmx, mmy ! Calcula los valores maximos y minimos mx = floor(minval(matriz(:,x))) my = floor(minval(matriz(:,y))) mmx = ceiling(maxval(matriz(:,x))) mmy = ceiling(maxval(matriz(:,y))) ! para poner los max y min

open (unit=3,file="pp.prg",status='old', position='append') write(3,'(A12,I4,A1,I4,A1)') "set xrange [", mx, ":", mmx, "]" write(3,'(A12,I4,A1,I4,A1)') "set yrange [", my, ":", mmy, "]" write(3,'(A)') "set size 0.5,0.5" write(3,'(A,F3.2,A1,F3.2)') "set origin ", 0.5*posx,",", 0.5*posy write(3,'(A12,A)') "set xlabel ", sx write(3,'(A12,A)') "set ylabel ", sy write(3,'(A6,A,A7,I2,A1,I2,A3,A)') "plot '",archivo_prov, "' using ", x, ":", y, " t ",etiqueta close(3) end Subroutine agrega_grafica !***************************************************! ! Esta subrutina grafica los errores de Declinacion contra los errores de Angulo horario para que el ! usuario tenga una idea de la magnitud de los errores. Se llama al inicio del programa y al final ! para poder comparar los errores iniciales contra los finales ! subroutine grafica_errores(etiqueta, rmsdec, rmsah) character(len = *), intent(in) :: etiqueta real, intent(out) :: rmsdec, rmsah integer matriz(:,1) = arreglo%dDec matriz(:,2) = arreglo%dAH ! Calcula los valores maximos y minimos mx = floor(minval(matriz(:,1))) my = floor(minval(matriz(:,2))) mmx = ceiling(maxval(matriz(:,1))) mmy = ceiling(maxval(matriz(:,2))) :: mx, my, mmx, mmy ! para poner los max y min

rmsdec = calcula_rms(matriz(:,1)) rmsah = calcula_rms(matriz(:,2)) call guarda_lineas("prov_i.txt", matriz) open (unit=3,file="pp.prg",status='replace') write(3,'(A)') "set origin 0,0" write(3,'(A)') "set size 1,1" write(3,'(A12,I4,A1,I4,A1)') "set xrange [", mx, ":", mmx, "]" write(3,'(A12,I4,A1,I4,A1)') "set yrange [", my, ":", mmy, "]" write(3,'(A,F5.1,A)') "set xlabel 'dDec: ", rmsdec, " rms'" write(3,'(A,F5.1,A)') "set ylabel 'dAH: ", rmsah, " rms'" write(3,'(A,A)') "plot 'prov_i.txt' using 1:2 t ", etiqueta close(3) call inicia_grafica() end subroutine grafica_errores !***************************************************! ! Esta subrutina se encarga de hacer los calculos necesarios para encontrar los coeficientes del ! modelo de correccion correspondientes a Declinacion. Solicita al usuario la confirmacion de ! las correcciones. El usuario debe decidir si se hacen las correcciones o no, en funcion de la ! informacion presentada, en particular la correlacion del ajuste ! subroutine encuentra_coeficientes_dec() ! Pone en la primera columna los errores en declinacion antes de ninguna correccion integer :: tam, kk matriz(:,1) = arreglo%dDec ! En la segunda columna pone el termino de flexiones del tubo; en los calculos, va ! multiplicando a Dec, que esta dada en grados, por el termino 'gra_rad' para ponerla ! en radianes y a AH, que esta en horas, por 'horas_rad' matriz(:,2) = -senphi*cos(arreglo%Dec*gra_rad) + & cosphi*sin(arreglo%Dec*gra_rad)*cos(arreglo%AH*horas_rad); !!!!! Primer ajuste (para el termino FT) !!!!! ! Calcula la mejor recta que se ajusta a esta distribucion call ajusta_recta(matriz(:,2), matriz(:,1), m(1), b(1), correlacion(1)) ! Imprime los valores de m, b y la correlacion para que el usuario decida si se

! aplica la correccion write(*,'(A,3F14.6)') " Flexiones del tubo: m, b y corr=", m(1), b(1), correlacion(1) ! Pregunta si aplica la correccion write(*,'(/a)', advance = "no") "Aplico esta correccion (s,n)? " read(*,*) resp if(resp == "s") then ! Corrige los errores usando la recta encontrada arreglo%dDec = arreglo%dDec-( m(1)*matriz(:,2) + b(1) ); FT = m(1) DI = DI + b(1) endif ! En la tercera columna de la matriz pone los errores con esta primera correccion; si no hubo ! correccion se dejan como estaban pero se ponen en esa columna para poder graficarlos matriz(:,3) = arreglo%dDec ! En la cuarta columna pone el termino de flexiones del yugo + alineacion vertical al polo matriz(:,4) = cos(arreglo%AH*horas_rad); !!!!! Segundo ajuste (para el termino PV_FY) !!!!! ! Calcula la mejor recta que se ajusta a esta distribucion call ajusta_recta(matriz(:,4), matriz(:,3), m(1), b(1), correlacion(1)) write(*,'(A,3F14.6)') " Flexiones del yugo y no alin. vertical: m, b y corr=", m(1), b(1), correlacion(1) ! De nuevo, dejamos que el usuario decida write(*,'(/a)', advance = "no") "Aplico esta correccion (s,n)? " read(*,*) resp if(resp == "s") then ! Corrige los errores usando la recta encontrada arreglo%dDec = arreglo%dDec-( m(1)*matriz(:,4) + b(1) ); PV_FY = m(1) DI = DI + b(1) endif ! En la columna 5 de la matriz pone los errores para ser graficados despues matriz(:,5) = arreglo%dDec ! Y en la columna 6 pone el termino de alineacion horizontal al polo matriz(:,6) = sin(arreglo%AH*horas_rad)

!!!!! Tercer ajuste (termino PH) !!!!! ! Calcula la mejor recta que se ajusta a esta distribucion call ajusta_recta(matriz(:,6), matriz(:,5), m(1), b(1), correlacion(1)) write(*,'(A,3F14.6)') " No alin. horiz.: m, b y corr=", m(1), b(1), correlacion(1) ! Igual. Dejamos que el usuario decida write(*,'(/a)', advance = "no") "Aplico esta correccion (s,n)? " read(*,*) resp if(resp == "s") then ! Corrige los errores usando la recta encontrada arreglo%dDec = arreglo%dDec-( m(1)*matriz(:,6) + b(1) ); PH = m(1) DI = DI + b(1) endif ! En la columna 7 de la matriz pone los errores para ser graficados despues matriz(:,7) = arreglo%dDec ! Aqui los datos estan acomodados como sigue: ! Col 1 | 2 | 3 | 4 | 5 | 6 | 7 ! ! --------------------------------------------------------------! ! dDec | FT | dDec_FT | PV_FY | dDec_PV_FY | PH | dDec_PH ! call guarda_lineas("prov.txt", matriz) call call call call call call prepara_archivo_de_grafica() agrega_grafica(2,1,'"FT"', '"dDec"', 0, agrega_grafica(4,3,'"PV+FY"', '"dDec"', agrega_grafica(6,5,'"PH"', '"dDec"', 0, agrega_grafica(2,7,'"FT"', '"dDec"', 1, inicia_grafica()

1,'"Flexiones del tubo"', "prov.txt") 1, 1,'"Flex. yugo + No alin. vert."', "prov.txt") 0,'"No alin. horiz."', "prov.txt") 0,'"Errores corregidos vs. FT"', "prov.txt")

tam = size(matriz(:,7)) do kk = 1, tam if( matriz(kk,7) < -30) then write(*,*) "El valor es: ",matriz(kk,7), "con kk = ", k endif enddo end subroutine encuentra_coeficientes_dec

!***************************************************! ! Como en el caso de Declinacion, esta subrutina se encarga de hacer los calculos necesarios para ! encontrar los coeficientes del modelo de correccion correspondientes al Angulo Horario. Tambien ! solicita al usuario la confirmacion de las correcciones, para que sea el usuario el que decida ! si se hacen las correcciones o no. ! subroutine encuentra_coeficientes_ah() real :: media_mas, media_menos integer :: cuantos_mas integer :: cuantos_menos media = 0.0 cuantos_mas = 0 cuantos_menos = 0 media_mas media_menos cuantos_mas cuantos_menos media_mas media_menos = = = = = = sum(arreglo%dAH, mask = arreglo%AH > 0) sum(arreglo%dAH, mask = arreglo%AH <= 0) count(arreglo%AH > 0) count(arreglo%AH <= 0) media_mas/cuantos_mas media_menos/cuantos_menos

! Pone en la primera columna los errores en AH antes de ninguna correccion matriz(:,1) = arreglo%dAH ! Pone en la columna 9 AH para graficar despues matriz(:,9) = arreglo%AH ! Pregunta si aplica la correccion write(*,'(/a,F6.1,/a)', advance = "no") "Encontre un error de backlash de ", media_mas-media_menos, & "Aplico esta correccion (s,n)? " read(*,*) resp if(resp == "s") then ! Corrige los errores restando el backlash a los del lado positivo where(arreglo%AH > 0) arreglo%dAH = arreglo%dAH - (media_mas - media_menos) BL = (media_mas - media_menos) endif ! Ahora corrige con los coeficientes que ya conoce arreglo%dAH = arreglo%dAH - FT*cosphi*sin(arreglo%AH*horas_rad)*sin(arreglo%Dec*gra_rad) arreglo%dAH = arreglo%dAH + PH*cos(arreglo%AH*horas_rad)*tan(arreglo%Dec*gra_rad) ! Pone en la segunda columna los errores en AH despues de las correcciones conocidas

matriz(:,2) = arreglo%dAH ! En la tercera columna pone el termino de falta de alineacion vertical matriz(:,3) = tan(arreglo%Dec*gra_rad)*sin(arreglo%AH*horas_rad); ! Limita los valores pues la tangente puede hacerse muy grande where(matriz(:,3) > 1000) matriz(:,3) = 1000 where(matriz(:,3) < -1000) matriz(:,3) = -1000 ! Calcula la mejor recta que se ajusta a esta distribucion call ajusta_recta(matriz(:,3), matriz(:,2), m(1), b(1), correlacion(1)) write(*,'(A,3F14.6)') " No alineacion vertical: m, b y corr=", m(1), b(1), correlacion(1) ! Pregunta si aplica la correccion write(*,'(/a)', advance = "no") "Aplico esta correccion (s,n)? " read(*,*) resp if(resp == "s") then ! Corrige los errores usando la recta encontrada arreglo%dAH = arreglo%dAH-( m(1)*matriz(:,3) + b(1) ); PV = m(1) HI = HI + b(1) endif ! En la cuarta columna pone los errores con la correccion anterior matriz(:,4) = arreglo%dAH ! En la quinta columna pone el termino de falta de perpendicularidad matriz(:,5) = tan(arreglo%Dec*gra_rad); ! Tambien limitamos los valores de la tangente where(matriz(:,5) > 1000) matriz(:,5) = 1000 where(matriz(:,5) < -1000) matriz(:,5) = -1000 ! Calcula la mejor recta que se ajusta a esta distribucion call ajusta_recta(matriz(:,5), matriz(:,4), m(1), b(1), correlacion(1)) write(*,'(A,3F14.6)') " No perpendicularidad: m, b y corr=", m(1), b(1), correlacion(1) ! Pregunta si aplica la correccion write(*,'(/a)', advance = "no") "Aplico esta correccion (s,n)? " read(*,*) resp if(resp == "s") then ! Corrige los errores usando la recta encontrada arreglo%dAH = arreglo%dAH-( m(1)*matriz(:,5) + b(1) ); NP = m(1) HI = HI + b(1)

endif ! En la columna 6 pone los errores con la correccion anterior matriz(:,6) = arreglo%dAH ! En la columna 7 pone el termino de falta de colimacion matriz(:,7) = 1.0/cos(arreglo%Dec*gra_rad); where(matriz(:,7) > 1000) matriz(:,7) = 1000 where(matriz(:,7) < -1000) matriz(:,7) = -1000 ! Calcula la mejor recta que se ajusta a esta distribucion call ajusta_recta(matriz(:,7), matriz(:,6), m(1), b(1), correlacion(1)) write(*,'(A,3F14.6)') " Colimacion: m, b y corr=", m(1), b(1), correlacion(1) ! Pregunta si aplica la correccion write(*,'(/a)', advance = "no") "Aplico esta correccion (s,n)? " read(*,*) resp if(resp == "s") then ! Corrige los errores usando la recta encontrada arreglo%dAH = arreglo%dAH-( m(1)*matriz(:,7) + b(1) ) CO = m(1) HI = HI + b(1) endif ! En la columna 8 pone los errores con todas las correcciones matriz(:,8) = arreglo%dAH ! Aqui los datos estan acomodados como sigue: ! Col 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 ! ! ---------------------------------------------------------------------------! ! dAH | dAH_ | PV | dAH_PV | NP | dAH_PV_NP | CO | dAH_PV_NP_CO | AH ! call guarda_lineas("prov_ah.txt", matriz) call call call call call call prepara_archivo_de_grafica() agrega_grafica(9,1,'"AH"', '"dAH"', agrega_grafica(3,2,'"PV"', '"dAH"', agrega_grafica(5,4,'"NP"', '"dAH"', agrega_grafica(7,6,'"CO"', '"dAH"', inicia_grafica()

0, 1, 0, 1,

1,'"Errores iniciales"', "prov_ah.txt") 1,'"Alineacion vertical"', "prov_ah.txt") 0,'"Falta de perpendicularidad"', "prov_ah.txt") 0,'"Falta de colimacion"', "prov_ah.txt")

end subroutine encuentra_coeficientes_ah end module utilerias

!*************************************************************! ! Empieza el programa ! !*************************************************************! Program calcula_modelo ! Trate de poner lo mas posible en subrutinas en el modulo a fin de hacer el programa ! mas compacto. use utilerias implicit none character(len=40) integer real ! :: archivo :: n_lineas ! Para el nombre del archivo que ! contiene los datos ! Numero de lineas en el archivo ! En este modulo estan las subrutinas

:: rmsdec, rmsah, rmsdec_ant, rmsah_ant, dummy Primero pide al usuario el nombre del archivo con los datos

write(unit=*, fmt='(a)', advance="no") "Teclea el nombre del archivo con los datos: " read(*,*) archivo ! do Pide al usuario la latitude del observatorio y verifica que sea un numero razonable write(unit=*, fmt='(/a,f4.1,a)', advance="no") "Dame la latitud del observatorio en grados (", phi/gra_rad, "): " read(*,*) dummy if(dummy > -80.0 .and. dummy < 80.0) exit enddo phi senphi cosphi ! ! = dummy*gra_rad = sin(phi) = cos(phi) ! la convierte en radianes ! Esto es el seno de la latitud ! Esto es el coseno de la latitud

Luego calcula el numero de renglones del archivo para definir los arreglos ! Verifica que exista y revisa cuantas lineas ! con datos tiene

n_lineas = cuantas_lineas(archivo) print*, "Hay", n_lineas, "lineas validas"

! Si no hay lineas validas, termina el proceso

if(n_lineas == 0) return allocate(arreglo(n_lineas)) allocate(matriz(n_lineas,9)) ! Acomoda el arreglo de n_lineas ! Acomoda la matriz donde pondra ! los datos a graficar ! Trae todos los datos y los pone en 'arreglo'

call trae_lineas(archivo, arreglo)

! Luego verifica que AH este entre -12 y 12 where(arreglo%AH > 12.0) arreglo%AH = arreglo%AH-24.0; call grafica_errores('"Errores iniciales"', rmsdec_ant, rmsah_ant) ! Aqui llama a una subrutina que calcula los coeficientes de correccion para la ! Declinacion call encuentra_coeficientes_dec() ! Luego llama a otra subrutina para calcular los coeficientes de correccion para ! el Angulo Horario call encuentra_coeficientes_ah() call grafica_errores('"Errores finales"', rmsdec, rmsah) ! Muestra los coeficientes calculados write(*,'(/A)') "Los coeficientes calculados son:" write(*,'(/A,F8.3)') " (Alineacion horizontal) - PH: ", PH write(*,'(A,F8.3)') " (Alineacion vertical) - PV: ", PV write(*,'(A,F8.3)') " (Flexion del tubo) - FT: ", FT write(*,'(A,F8.3)') " (Flexion del yugo) - FY: ", PV_FY - PV write(*,'(A,F8.3)') "(Falta de perpendicularidad) - NP: ", NP write(*,'(A,F8.3)') " (Error de colimacion) - CO: ", CO write(*,'(A,F8.3)') " (Backlash en AH) - BL: ", BL write(*,'(A,F8.3)') " (Offset en AH) - HI: ", HI write(*,'(A,F8.3)') " (Offset en Dec) - DI: ", DI write(*,'(/A)') "Con esta correccion se han bajado del errores RMS como sigue:" write(*,'(A,F5.1,A,F5.1,A)') " AH: de ", rmsah_ant, " a ", rmsah, " (arcsec)" write(*,'(A,F5.1,A,F5.1,A)') "Dec: de ", rmsdec_ant, " a ", rmsdec, " (arcsec)" ! Pregunta si cerramos los graficos write(*,'(/a)', advance = "no") "Cierro los graficos (s,n)? " read(*,*) resp

if(resp == "s") then call system("killall gnuplot_x11") ! Cierra todas las ventanas con gnuplot endif deallocate(arreglo) deallocate(matriz) End Program calcula_modelo !************************************************************************

Apndice B. Listado del programa en IDL

FUNCTION rms, vector media = mean(vector) va = vector - media return, sqrt(mean(va*va)) END

PRO encuentra_modelo, ARCHIVO=archivo, LATITUD=latitud, CORRIGE=corrige ;********************************************************************************** ; Programa 'encuentra_modelo.pro' elaborado por Leonel Gutierrez . ; ; Este programa lee un archivo con una serie de datos que muestran ; los errores de apuntado de un telescopio con montura ecuatorial ; y calcula los coeficientes de un modelo trigonometrico para corregir ; dicho apuntado. ;********************************************************************************** ; sintaxis: ENCUENTRA_MODELO, archivo="epos.txt", latitud=19.5, corrige=[1,1,1,0,1,0,1] if (NOT keyword_set(ARCHIVO)) then archivo="epos.txt" if (NOT keyword_set(LATITUD)) then latitud=19.5 if (NOT keyword_set(CORRIGE)) then begin corrigePH=1 corrigePV=1 corrigeFT=1 corrigePV_FY=1 corrigeNP=1 corrigeCO=1 corrigeBL=1 endif else begin if n_elements(corrige) ne 7 then begin print, "Corrige debe tener 7 elementos en el orden [PH,PV,FT,PV_FY,NP,CO,BL]." print, "Poner 1 en la correccion que se desea y 0 en la que no." return endif corrigePH=corrige(0) corrigePV=corrige(1)

corrigeFT=corrige(2) corrigePV_FY=corrige(3) corrigeNP=corrige(4) corrigeCO=corrige(5) corrigeBL=corrige(6) endelse ;Trae los datos del archivo readcol,archivo,f='(f,f,f,f)', ah, dah, dec, ddec ; Inicia una ventana para desplegar las graficas window, 1, xsi=300,ysi=300,retain=2, title="Errores iniciales" white = !D.N_COLORS-1 !P.color = 0 !p.background = white ; Desplegara solo una grafica !p.multi = [0,1,1,0,0] sx = "dDec (rms=" +string(rms(dDec),f='(f6.2)') + ")" sy = "dAH (rms=" +string(rms(dAH),f='(f6.2)') + ")" plot,ddec,dah,psym=4,symsize=0.5,xtitle=sx, ytitle=sy print, "rms de dAH y dDec (antes): ", rms(dAH), rms(dDec) ; Mi definicion de PI pi=acos(-1) ; Pone la latitud y calculas el seno y el coseno phi=latitud senphi = sin(phi*pi/180.0) cosphi = cos(phi*pi/180.0) ; Inicia otra ventana para desplegar el proceso de correccion en declinacion window, 2, xsi=600,ysi=600,retain=2, title="Correcciones en declinacion" ; Desplegara 4 graficas !p.multi = [0,2,2,0,0] ; Para calcular el termino correspondiente a las flexiones del tubo term1 = -senphi*cos(dec*pi/180.0) + cosphi*sin(dec*pi/180.0)*cos(ah*15*pi/180.0) ; Grafica los errores plot,term1,ddec,psym=4,symsize=0.5,xtitle='FT', ytitle='dDec' xyouts, 120,260+300,"Flexiones del tubo", /device ; Ajusta una recta y calcula FT params = fltarr(2)

params = linfit(term1,ddec) DI = params(0) FT = 0.0 if corrigeFT then begin FT = params(1) ; Corrige los errores ddec = ddec - (FT*term1 + DI) endif ; Para corregir las flexiones del yugo y la falta de alineacion vertical term2 = cos(ah*15*pi/180.0) plot, term2,ddec,psym=4,symsize=0.5,xtitle='PV+FY', ytitle='dDec' xyouts, 120+300,260+300,"Flex. yugo + alin. vert.", /device ; Ajusta una recta y calcula PV_FY params = linfit(term2,ddec) DI = params(0) + DI PV_FY = 0.0 if (corrigePV_FY) then begin PV_FY = params(1) ; Corrige los errores ddec = ddec-(PV_FY*term2 + params(0)) endif ; Para corregir la falta de alineacion horizontal term3 = sin(ah*15*pi/180.0) plot, term3,ddec,psym=4,symsize=0.5,xtitle='PH', ytitle='dDec' xyouts, 120,260,"Alin. horizontal", /device ; Ajusta una recta y calcula FT params = linfit(term3,ddec) DI = params(0) + DI PH = 0.0 if (corrigePH) then begin PH = params(1) ; Corrige los errores ddec = ddec-(PH*term3 + params(0)) endif ; Grafica los errores en declinacion una vez corregidos

plot,term1,ddec,psym=4,symsize=0.5,xtitle='FT', ytitle='dDec' xyouts, 120+300,260,"Errores corregidos en Dec", /device

; Inicia otra ventana para desplegar el proceso de correccion en AH window, 3, xsi=600,ysi=600,retain=2, title="Correcciones en AH" ; Grafica los errores plot,AH,dAH,psym=4,symsize=0.5,xtitle='AH', ytitle='dAH' xyouts, 120,260+300,"Errores iniciales", /device ; Para calcular el Backlash, calcula la media de los errores donde AH > 0 crit = where(ah>0) mediamas = mean(dAh(crit)) ; Luego calcula la media del lado negativo crit1 = where(ah<0) mediamenos = mean(dAh(crit1)) ; Calcula el backlash BL = mediamas - mediamenos if (corrigeBL) then begin ; Lo resta a los del lado positivo dah(crit) = dah(crit) - BL endif ; Corrige los errores en AH con los terminos que ya se conocen dah=dah-FT*cosphi*sin(ah*15*pi/180.0)*sin(dec*pi/180.0) dah = dah + PH*cos(ah*15*pi/180.0)*tan(dec*pi/180.0) ; Para corregir por falta de alineacion vertical term4 = sin(ah*15*pi/180.0)*tan(dec*pi/180.0) plot, term4,dah,psym=4, symsize=0.5,xtitle='PV', ytitle='dDec' xyouts, 120+300,260+300,"Alineacion vertical", /device ; Ajusta una recta y calcula PV params = linfit(term4,dAH) HI = params(0) PV = 0.0 if (corrigePV) then begin PV = params(1)

; Corrige los errores dAH = dAH-(PV*term4 + params(0)) endif ; Para corregir por perpendicularidad term5 = tan(dec*pi/180.0) plot, term5,dah,psym=4, symsize=0.5,xtitle='NP', ytitle='dDec' xyouts, 120,260,"Perpendicularidad", /device ; Ajusta una recta y calcula NP params = linfit(term5,dAH) HI = HI + params(0) NP = 0.0 if (corrigeNP) then begin NP = params(1) ; Corrige los errores dAH = dAH-(NP*term5 + params(0)) endif ; Para corregir por falta de colimacion term6 = 1.0/cos(dec*pi/180.0) plot, term6,dah,psym=4, symsize=0.5,xtitle='CO', ytitle='dDec' xyouts, 120+300,260,"Falta de colimacion", /device ; Ajusta una recta y calcula CO params = linfit(term6,dAH) HI = HI + params(0) CO = 0.0 if (corrigeCO) then begin CO = params(1) ; Corrige los errores dAH = dAH-(CO*term6 + params(0)) endif ; Inicia otra ventana para desplegar la grafica final window, 4, xsi=300,ysi=300,retain=2, title="Errores corregidos" ; Desplegara solo una grafica !p.multi = [0,1,1,0,0] sx = "dDec (rms=" +string(rms(dDec),f='(f6.2)') + ")" sy = "dAH (rms=" +string(rms(dAH),f='(f6.2)') + ")"

plot,ddec,dah,psym=4,symsize=0.5,xtitle=sx, ytitle=sy print, print, print, print, print, print, print, print, print, " (Alineacion horizontal) " (Alineacion vertical) " (Flexiones del tubo) " (Flexiones del yugo) "(Falta de perpendicularidad) " (Error de colimacion) " (Backlash en AH) " (Offset en AH) " (Offset en Dec) PH: PV: FT: FY: NP: CO: BL: HI: DI: ", ", ", ", ", ", ", ", ", PH PV FT PV_FY - PV NP CO BL HI DI

print, "rms de dAH y dDec (despues): ", rms(dAH), rms(dDec) END