Operativo¶

El archivo que se ejecuta diariamente es Build_WRF/OPERATIVO/runners/cron.bash, mediante un cron que se puede acceder ejecutando:

crontab -e

y fijando la hora en el día que se ejecuta:

30 18 * * * cd ~/Build_WRF/OPERATIVO/runners/ && ./cron.bash

cron.bash¶

En primer lugar, este script copia los namelists modelos para todos los procesos del WRF:

cd ~/Namelists/ && ./cpNamelists

Luego ejecuta el WRF llamando al archivo que tiene todas las instrucciones:

fecha=`date +"%Y%m%d"`
cd ~/Build_WRF/OPERATIVO/runners/ && mkdir logs/$fecha && ./runEureka.bash > logs/$fecha/eureka.log

Las impresiones de las corridas de todos los programas se iran guardando en la carpeta logs/$fecha/ con $fecha de la forma AAAAMMDD.

Una vez termido el programa, envía un mail con los gráficos:

cat ~/Build_WRF/OPERATIVO/reporte1.txt | mutt -s "Pronostico WRF - $fecha_mail" -a ~/Build_WRF/OPERATIVO/public/*.* -c mail@mail.com

Por último controla si queda poco espacio en el disco duro, y en caso de quedar poco espacio, envía un mail de alerta:

umbral=80
volumen=`df -h /dev/sda | tail -1 | awk '{print $4}'`
volumen=${volumen:0:-1}
porcentaje=`df -h /dev/sda | tail -1 | awk '{print $5}'`
if [ $volumen -lt $umbral ]; then
echo "El espacio que queda disponible es " $volumen"GB! (" $porcentaje" ocupado). Tener en cuenta que por día se generan entre 22 y 25 GB." | mutt -s "AVISO de falta de espacio en el servidor de WRF" -c mail@mail.com
fi

runEureka.bash¶

Primero se fijan algunas variables globales para todo el script:

path=   #ruta donde está ubicado la carpeta del WRF
datos_estaciones=       #ruta donde está ubicado el script para almacenar los datos de las estaciones
scriptdir=$path/OPERATIVO/DESCARGA      #ruta donde está ubicado el script descargar los GFS
fecha=`date +"%Y%m%d"`18        #fecha de interés para empezar a descargar los GFS
data=$path/DATA/GFS025/GFS_$fecha       #ruta donde guarda los GFS

Luego se descargan los datos GFS con el programa Build_WRF/OPERATIVO/DESCARGA/get_GFSX025_grib2.py (ver Descarga de GFS) y almacenarlos en Build_WRF/DATA/GFS025/GFS_AAAAMMDD18. En caso de no poder descargarlos, el programa vuelve a intentar cada 1 hora.

Más tarde se fija la fecha de inicio y fecha de fin:

start_date=$(date -d $fecha +%Y-%m-%d)_18:00:00
end_date=$(date -d $fecha" 2 days" +%Y-%m-%d)_03:00:00
run_hours=39

y se ejecutan todos los pasos del WRF:

Ejecuta el WPS (ver runWPS.bash):
time ./runWPS.bash $start_date $end_date $run_hours $data $path > logs/${fecha:0:-2}/wps.log
Ejecuta el WRF (ver runWRF.bash):
time ./runWRF.bash $start_date $end_date $run_hours $data $path > logs/${fecha:0:-2}/wrf.log
Ejecuta el ARWpost (ver runARWpost.bash) para generar la salida que pueda leer GrADS:
time ./runARWpost.bash $start_date $end_date $wrfout $path > logs/${fecha:0:-2}/arw.log

Una vez finalizado el WRF, se generan las visualizaciones (ver runVis.bash):

./runVis.bash $path > logs/${fecha:0:-2}/visualizaciones.log

Luego se guardan los datos pronosticados de los puntos donde hay estaciones, para su posterior analisis (ver Analisis de Datos):

time python $datos_estaciones/datos_pronosticados.py --datoswrf="$path/ARWpost/test.ctl" --estacionescsv="$datos_estaciones/estaciones.csv" > logs/${fecha:0:-2}/analisis_datos.log

Y por último se realiza una copia de las salidas y los GFS descargados en la carpeta Build_WRF/ARWpost/Salidas/$fecha/:

cp -r $path/OPERATIVO/public $path/ARWpost/Salidas
mv $path/ARWpost/Salidas/public $path/ARWpost/Salidas/$fecha
cp -r $path/DATA/GFS025/GFS_$fecha $path/ARWpost/Salidas/$fecha
cp $path/ARWpost/test.dat $path/ARWpost/Salidas/$fecha
cp $path/ARWpost/test.ctl $path/ARWpost/Salidas/$fecha

Descarga de GFS¶

Para descargar los datos se desarrolló un script ( get_GFSX025_grib2.py ) que los obtiene de http://nomads.ncep.noaa.gov/ para una fecha dada.

get_GFSX025_grib2.py

Descarga los datos para la fecha dada.

Argumentos:

ini : Fecha de inicio de los datos que se quiere descargar en el formato AAAAMMDDHH
output : ruta donde se almacenan los archivos descargados

Ejecutar:

python get_GFSX025_grib2.py --ini=$fecha --output=$data

OPERATIVO.DESCARGA.get_GFSX025_grib2.download(inidate, output)¶

Se descargan los datos con los siguientes parámetros:

LON_W="-96"  # límite de longitud oeste de la grilla 
LON_E="-15"  # límite de longitud este de la grilla 
LAT_N="-10"  # límite de latitud norte de la grilla 
LAT_S="-75"  # límite de latitud sur de la grilla
ADGRID="0.25"  # resolución de la grilla
NHOUR=39  # cantidad de horas que en que se descargan datos 
DHOUR=03 # intervalo en horas en que se vuelve a descargar
LEV_LIST=["all"] # niveles solicitados
PAR_LIST=["HGT","LAND","PRES","PRMSL","RH","SOILW","SPFH","TMP","UGRD","VGRD","WEASD","TSOIL"]  # parámetros solicitados

runWPS.bash¶

Este script realiza el preprocesamiento (WPS), como datos de entrara toma:

start_date : fecha en que comienza el pronóstico

end_date : fecha hasta donde pronostica

run_hour : cantidad de horas de pronóstico

data : ruta donde se encuentran los GFS de entrada

path : ruta raiz del WRF

Primero carga los archivos de parámetros de WPS (ver Namelists de WPS), hace una coia temporal y edita los valores de la fecha y datos geográficos.

Luego se ejecutan los 3 programas del preprocesamiento:

1. Se ubica en la carpeta de WPS::

        cd WPS/

2. Se ejecuta `geogrid`, que sirve para definir los dominios de simulación e interpolar datos terrestres::

        time ./geogrid.exe

  Este programa genera como salida ``WPS/geo_em.d01.nc``

3. Se genera enlace a la `Vtable`, tabla de códigos que sirve para definir que campos extraer de los archivos GRIB::

        time ln -sf ungrib/Variable_Tables/Vtable.GFS Vtable

4. Se generan enlaces a los archivos GFS descargados::

        time ./link_grib.csh $data/"GFS_"

5. Se ejecuta `ungrib`, que descomprime los archivos GRIB con los datos requeridos en la `Vtable` para que queden en un formato intermedio::

        time ./ungrib.exe

6. A partir de las salidas de `geogrid` y `ungrib` se ejecuta `metgrid`, que interpola los datos de entrada en el dominio de interés::

        time ./metgrid.exe

  Este comando crea los archivos ``WPS/met_em.*``, las salidas del preprocesamiento.

7. Se vuelve el `namelist` a su estado inicial con el archivo temporal que se guardó::

        rm $namlist_wps
        mv $namlist_wpsTemp $namlist_wps

runWRF.bash¶

Este script realiza el procesamiento (WRF) de WRF. Como datos de entrada toma:

start_date : fecha en que comienza el pronóstico

end_date : fecha hasta donde pronostica

run_hour : cantidad de horas de pronostico

data : ruta donde se encuentran los GFS de entrada

path : ruta raiz del WRF
Se ubica en la carpeta de WRF:
cd WRFV3/test/em_real
Se crean los enlaces a las salidas del preprocesamiento:
time ln -sf $dirWPS/met_em.* .
Se editan los parámetros del namelist.wrf (ver Namelists de WRF) con la fecha y hora de comienzo y de fin:
sed -i "s/RUN_HOURS/$run_hour/g" $namlist_input
sed -i "s/START_YEAR/$year_start/g" $namlist_input
        .
        .
        .
sed -i "s/END_SECOND/$second_end/g" $namlist_input
Se ejecuta real, que interpola verticalemte los datos y crea los datos de condición inicial y de contorno:
time ./real.exe
Este programa genera las salidas WRFV3/test/em_real/wrfinput_d01 y WRFV3/test/em_real/wrfbdy_d01
Se ejecuta wrf:
time ./wrf.exe
La salida se guarda en WRFV3/test/em_real/wrfout_d01_AAAA-MM-DD_18:00:00
Se vuelve el namelist a su estado inicial con el archivo temporal que se guardó:
rm $namlist_input
mv $namlist_inputTemp $namlist_input

runARWpost.bash¶

Este script realiza el posprocesamiento (ARWpost) en el cual vamos a convertir la salida del WRF en un formato que pueda leer GrADS. Este programa toma como datos de entrada:

start_date : fecha en que comienza el pronóstico

end_date : fecha hasta donde pronostica

wrfout : nombre de la salida del WRF

path : ruta raiz del WRF

En primer lugar, se crea una copia del archivo de parámetros de ARWpost (ver Namelists de ARWpost) y se modifica con la fecha de comienzo, de fin y la salida del WRF.

Luego ejecuta ARWpost:

time ./ARWpost.exe

La salida se guarda en ARWpost/test.ctl y ARWpost/test.dat

Y por último vuelve el namelist.arwpost a su estado original con la copia temporal.