Informática Aplicada a la Investigación Rotating Header Image

F.A.Q.

Cómo mandar NWchem

send_nwchem

Para lanzar al sistema de colas Nwchem existe la utilidad send_nwchem. Al ejecutarlo, muestra la sintaxis del comando, que se resume a continuación:

send_nwchem JOBNAME PROCS[property] TIME MEM [``Otherqueue options'' ]

  • JOBNAME: Nombre del input de nwchem sin extensión.
  • PROCS: Número de procesadores.
  • TIME: Tiempo solicitado a la cola, formato hh:mm:ss.
  • MEM: memoria en GB y sin especificar la unidad.
  • [“Otras opciones de Torque”] Existe la posibilidad de pasar más variables al sistema de colas. Ver ejemplos más abajo. Más información sobre estas opciones

Ejemplos

Mandamos NWchem con el input job1 a 1 nodo, 4 procesadores de ese nodo tipo itaniumb, con un tiempo solicitado de 4 horas y 1 GB de RAM:

send_nwchem job1 4:itaniumb 04:00:00 1

Mandamos NWchem con el input job2 a 2 nodos, 8 procesadores en cada nodo, con un tiempo solicitado de 192 horas, 8 GB de RAM y que se ejecute después del trabajo 1234.arina:

send_nwchem job2 16 192:00:00 8 ``-W depend=afterany:1234''

Mandamos NWchem con el input job3 a 4 nodos y 8 procesadores en cada nodo, con un tiempo solicitado de 200:00:00 horas, 2 GB de RAM y que nos envíe un mensaje de correo al inicio y final del cálculo a la dirección especificada.

send_nwchem job3 32 200:00:00 2 ``-m be -M mi.email@ehu.es''

El comando send_nwchem copia el contenido del directorio desde el que se lanza al /scratch o /gscratch -si se usan 2 o más nodos. Es allí donde realiza el cálculo.

qsub interactivo

Ejecutando

qsub

entramos en el modo qsub en interactivo y nos hace varias preguntas para preparar el trabajo, uno de los programas para los que está preparado es NWchem.

Monitorización de los cálculos

Para facilitar el seguimiento y/o control de los cálculos, existen las suiguientes herramientas (sólo si ha sido enviado usando send_nwchem o qsub interactivo):

  • remote_vi: Nos enseña con el editor gvim el *.out del cálculo de nwchem.
  • remote_molden: Nos enseña con el molden el *.out del cálculo de nwchem.
  • remote_xmakemol: Para dimámicas. Nos enseña con el xmakemol el *.md.xyz del cálculo de nwchem.
  • remote_qmde: Nos enseña con el xmgrace la evolución de la energía respecto al tiempo de un cálculo de Dinámica Molecular.

El uso de todas estar herramientas es muy similar, hay que ejecutarlas seguido el identificador que el cálculo tiene en el sistema de colas.

Ejemplos

remote_vi 1243.arina
remote_xmakemol 2390.arina
remote_molden 2390.arina
remote_qmde 3432.arina

ECCE

ECCE 4.0.2 (Extensible Computational Chemistry Environment) es una aplicación desarrollada por el mismo grupo que Nwchem (ECCE Homepage). Dispone de una interface grafica que permite preparar inputs para nwchem, gaussian, y otros programas de química cuántica. Para su uso simplemente hay que ejecutar:

ecce &

Os recomendamos ejecutar ECCE en maiz y usando Nomachine NX.

Más información

Manual en línea de NwChem.

~

Cómo mandar Gaussian

Comando send_gauss

El comando send_gauss envía los cálculos con g09.

Recomendamos el uso del comando send_gauss. Este comando preparará script de TORQUE y lo enviará a la cola. El fichero de log (*.log) se mantendrá en el /scratch del nodo de remoto, pero send_gauss envía el trabajo de tal menera que puede ser visualizado con las herramientas remote_vi y remote_molden (ver más abajo).

modo de uso del comando send_gauss es el siguiente:

send_gauss trabajo cola_o_tiempo num_proc [mem] [opciones de TORQUE]

donde:

  • trabajo: Es el nombre del input de gaussian sin la extensión (*.com).
  • cola o tiempo: Se puede indicar la cola a la que se quiere mandar el cálculo o el tiempo en formato (hh:mm:ss).
  • num_proc: El número de procesadores que se quiere usar por nodo, ha de ser igual o menor de 8 o un múltiplo de 8. Es posible añadir propiedades de los nodos, por ejemplo 8:itaniumb
  • mem:  la memoria en GB.
  • [opciones de TORQUE]: Opciones avanzadas que se quieren pasar al gestor de colas TORQUE.

Ejemplos

send_gauss h2o p_slow 8

Enviará el trabajo h2o en  1 nodo y 8 procesadores a la cola p_slow con los valores de memoria predeterminados en este caso 7.2Gb (nproc*900mb).

send_gauss h2o p_slow 16 20

Enviará el trabajo h2o en dos nodos y 8 procesadoresencada uno  a la cola p_slow con 20gb de memoria RAM.

send_gauss h2o 23:00:00 16:xeon 4 ``-m be -M niri@ehu.es -W depend=afterany:4827''

Enviará el trabajo h2o en 2 nodos Xeony 8 procesadoeres en cada uno,  con 4gb de RAM. El tiempo solicitado son 23 horas, y nos enviará un email al inicio y final del cálculo. Por otra parte este trabajo no empezará hasta que termine el trabajo 4827.

Comando qsub interactivo

Si se ejecuta simplemente qsub sin añadir ninguna orden más:

qsub

este entrará en modo interactivo, nos realizará unas preguntas simples, que nos guiará en el proceso para enviar varios tipos de trabajo de un modo sencillo. Más informacián en qsub interactivo.

qsub tradicional

Podemos construir nuestro propio script para Torque. En este enlace hay ejemplos adecuados.

Seguimiento del trabajo

Existen las herramietas remote_vi y remote_molden, que permiten ver el fichero .log o mostrar la estructura con Molden. Para ello hay que usar send_gaussian o qsub interactivo. Su uso el el siguiente:

remote_vi 2341
remote_molden 2341

o

remote_vi 2341.arina
remote_molden 2341.arina

donde 2341(.arina) es el identificador del trabajo en la cola.

Como Mandar Wien2k

Wien2k requiere de un fichero especial. Los scripts se envían al sistema de colas con el comando

qsub script_file

script_wien de script que ejecuta el programa run_lapw en paralelo es

#!/bin/bash
#PBS -l nodes=[val]:ppn=[val]
#PBS -l walltime=[val]
#PBS -l mem=[val]

# Vamos a nuestro home
cd $PBS_O_WORKDIR

#Creamos el fichero .machines
cat $PBS_NODEFILE |cut -c1-6 >.machines_current
aa=$(wc -l .machines_current |cut -d " " -f 1)
echo '#' > .machines

i=1
while [ $i -le $aa ];do
echo -n '1:' >>.machines
head -$i .machines_current |tail -1 >> .machines
let i=i+1
done
echo 'granularity:1' >>.machines
echo 'extrafine:1' >>.machines

#Nuestro directorio de scratch
scrt=/scratch/$USER/$(echo $PBS_O_WORKDIR |xargs basename)
outdir=bukatuta_$PBS_JOBID
export SCRATCH=$scrt/scratch

#Creamos el directorio
mkdir $scrt
mkdir $scrt/scratch

#Copiamos los archivos al directorio scratch
#Usaremos cp -r $scrt para copiar también subdirectorios.
cp $PBS_O_WORKDIR/* $scrt
cp .machines $scrt

#Nos movemos de directorio
cd $scrt

#Ejecutamos WIEN2k en paralelo
run_lapw -p
#Movemos los archivos finales
mkdir  $PBS_O_WORKDIR/$outdir
mv -f $scrt/* $PBS_O_WORKDIR/$outdir
mv -f $scrt/.machines $PBS_O_WORKDIR/$outdir

#Borramos el directorio
rmdir $scrt
rm .??*

Las líneas que comienzan con #PBS son órdenes para el gestor de colas que seleccionan:

nodes: Número de nodos en los que se va a ejecutar el programa (ejemplo [val]=2).

ppn: Número de microprocesadores por nodo que va a usar el programa (ejemplo [val]=4).

mem: Memoria RAM reservada para el cálculo, medida en mb o gb (ejemplo: [val]=100mb).

walltime: Tiempo de microprocesador reservado en formato hh:mm:ss (ejemplo: [val]=24:00:00).

En el script la variable $USER devuelve el nombre del usuario, $PBS_O_WORKDIR el directorio de trabajo desde donde se ejecuta el comando qsub$PBS_JOBID el número de identificación del trabajo.

Cómo mandar Qsite

send_qsite

send_qsite JOBNAME DONES PROCS_PER_NODE[property] TIME MEM [``Other queue options'']

  • JOBNAME: Nombre del input de siesta sin extensión.
  • NODES: Número de nodos.
  • PROCS: Número de procesadores.
  • TIME: Tiempo solicitado a la cola, formato hh:mm:ss.
  • MEM: memoria en Gb y sin especificar la unidad.
  • [“Other queue options”] Existe la posibilidad de pasar más variables al sistema de colas. Más información sobre estas opciones

Ejemplos:
Mandamos Jaguar con el input job1 a 1 nodo, 4 procesadores de ese nodo tipo itaniumb, con un tiempo solicitado de 4 horas y 1 GB de RAM:

  • send_qsite job1 1 4:itaniumb 04:00:00 1

Mandamos qsite con el input job3 a 2 nodos, 4 procesadores en cada nodo, con un tiempo solicitado de 60 horas, 8 GB de RAM y que se ejecute después del trabajo 1234.arinab:

  • send_qsite job3 2 4 60:00:00 8 ``-W depend=afterany:1234''

Mandamos qsite con el input job3 a 1 nodos y 4 procesadores en cada nodo, con un tiempo solicitado de 500 horas, 15 GB de RAM y que nos envíe un email al inicio y final del cálculo a la direción especificada.

  • send_qsite job3 1 4 400:00:00 15 ``-m be -M mi.email@ehu.es''

qsub interactivo

qsub

y seguir la instruciones.
La versión de QSITE disponible es la 5. Los manuales están disponibles en arina:/software/schrodinger/docs.

Como Mandar Gamess

Información General

Gamess es un paquete de química computacional con varios métodos para calcular propidedades de sistemas moleculares, usando descripciones mecanico-cuánticas estandar para las funciones de onda o la densidad electrónica. La versión 12 JAN 2009 (R1) se encuentra instalada en el cluster. En estos momentos, se podran ejecutar los trabajos de gamess en vários nodos, con 8 o más procesadores.

Comando send_gamess

Para mandar trabajos de gamess a la cola, recomendamos el uso del comando send_gamess. Este comando preparará script de TORQUE y lo enviará a la cola. El el *.log se mantendrá en el /scratch del nodo de remoto.

Modo de Uso del comando send_gamess :

send_gamess trabajo num_nodos num_proc tiempo MEM (opciones del TORQUE)

donde:

trabajo: es el nombre del input de gamess sin la extensión (*.com).
cola o tiempo: se puede indicar la cola a la que se quiere mandar el cálculo o el tiempo en formato (hh:mm:ss).
num_nodos: el número de nodos que se quiere usar.
num_proc: el número de procesadores que se quiere usar. Máximo 8. Es posible añadir propiedades de los nodos, por ejemplo 8:itaniumb
mem: La memoria en Gb. Si no se especifica, el valor por defecto es nproc*900mb.
(opciones del TORQUE) Opciones avanzadas que se quieren pasar al gestros de colas TORQUE. Más información sobre estas opciones

Ejemplos:

send_gamess ti3_cor 1 8 90:00:00 4

Enviará el trabajo ti3_cor en 1 nodo, con 8 procesadores, 90 horas de duración y 4Gb de memoria RAM.

send_gamess ti3_cor 4 8 190:00:00 16
Enviará el trabajo ti3_cor en 4 nodos, y 8 procs en cada nodo, solicitando 190 horas y 16gb de memoria RAM.

send_gamess ti3_cor 4 4:itanium4 23:00:00 4 ``-m be -M niris@ehu.es -W depend=afterany:4827''

Enviará el trabajo ti3_cor en 4 nodos con 4 procesadoeres que tengan la propiedad itanium4, 4gb de RAM. El tiempo solicitado son 23 horas, y nos enviará un email al inicio y final del cálculo. Por otra parte este trabajo no empezará hasta que termine el trabajo 4827.

Seguimiento del Cálculo

Para poder visualizarlo, tenemos disponibles las herramientas

Para relaizar el seguimiento del trabajo existen las herramietas remote_vi y remote_molden. Su uso el el siguiente:

remote_vi 2341
o
remote_vi 2341.arinab

donde 2341(/.arinab) es el identificador del trabajo en la cola.

qsub interactivo

También se puede lanzar gamess con el comando qsub interactivo.

Cómo mandar Terachem

Introducción

A parte de los scripts normales de Torque que se pueden escribir existe el comando send_terachem que facilita enviar los trabajos al sistema de colas.

send_terachem

Para mandar Terachem se ha definido el comando send_terachem:

send_terachem JOBNAME TIME MEM [``Other queue options'']

donde

JOBNAME: Nombre del input de Terachem sin extensión.
TIME: Tiempo solicitado a la cola, formato hh:mm:ss.
MEM: memoria en Gb y sin especificar la unidad.
[``Other queue options''] Existe la posibilidad de pasar más variables al sistema de colas.

Ejemplos

  • Mandamos Terachem con el input job1 con un tiempo solicitado de 4 horas y 1 GB de RAM.
send_terachem job1 04:00:00 1
  • Mandamos jaguar con el input job2, con un tiempo solicitado de 60 horas, 8 GB de RAM y que se ejecute después del trabajo 1234.arina.
send_terachem job3 60:00:00 8 ``-W depend=afterany:1234''
  • Mandamos jaguar con el input job3, con un tiempo solicitado de 500 horas, 15 GB de RAM y que nos envíe un email al inicio y final del cálculo a la direción especificada.
send_terachem job3 400:00:00 15 ``-m be -M mi.email@ehu.es''

Como Mandar Macromodel

El modo de uso es el siguiente:

send_mmodel JOBNAME

donde JOBNAME es el fichero de entrada sin extensión.

qsub interactivo

También se puede usar qsub interactivo para enviar macromodel.

Como Mandar Jaguar

Comando send_jaguar

Para mandar Jaguar se ha definido el comando send_jaguar:

send_jaguar JOBNAME NODES PROCS_PER_NODE TIME MEM [``Other queue options'']

donde

JOBNAME: Nombre del input de siesta sin extensión.
NODES: Número de nodos.
PROCS: Número de procesadores.
TIME: Tiempo solicitado a la cola, formato hh:mm:ss.
MEM: memoria en Gb y sin especificar la unidad.
[``Other queue options''] Existe la posibilidad de pasar más variables al sistema de colas. Más información sobre estas opciones

Ejemplos

  • Mandamos Jaguar con el input job1 a 1 nodo, 8 procesadores de ese nodo tipo itaniumb, con un tiempo solicitado de 4 horas y 1 GB de RAM.
send_jaguar job1 1 8:itaniumb 04:00:00 1
  • Mandamos jaguar con el input job3 a 2 nodos, 4 procesadores en cada nodo, con un tiempo solicitado de 60 horas, 8 GB de RAM y que se ejecute después del trabajo 1234.arinab.
send_jaguar job3 2 4 60:00:00 8 ``-W depend=afterany:1234''
  • Mandamos jaguar con el input job3 a 1 nodos y 8 procesadores en cada nodo, con un tiempo solicitado de 500 horas, 15 GB de RAM y que nos envíe un email al inicio y final del cálculo a la direción especificada.
send_jaguar job3 1 8 400:00:00 15 ``-m be -M mi.email@ehu.es''

Qsub interactivo

También se pueden enviar los cálculos con el qsub interactivo.

Cómo mandar trabajos de Siesta

Cómo mandar trabajos de siesta

Existen 3 posibilidades.

  1. Con el comando send-siesta.
  2. Con el comando qsub en interactivo.
  3. Con un scrtip tradicional para qsub.

Comando send_siesta

Si se ejecuta send_siesta muestra una ayuda de como ejecutarse. El modo de mso del comando send_siesta es el siguiente:

send_siesta JOBNAME NODES PROCS_PER_NODE[property] TIME MEM [``Other queue options'']

JOBNAME: Nombre del input de siesta sin extensión.
NODES: Número de nodos.
PROCS: Número de procesadores por nodo.
TIME: Tiempo solicitado a la cola, formato hh:mm:ss.
MEM: memoria en Gb y sin especificar la unidad.
[``Other queue options''] Existe la posibilidad de pasar más variables al sistema de colas. Más información sobre estas opciones

El comando send_siesta o qsub interactivo copia el contenido del directorio desde el que se lanza al /scratch o /gscratch -si se usan 2 o más nodos-. Y es allí donde realiza el cálculo.

Ejemplos

Mandamos Siesta con el input job1.fdf a 1 nodo, 4 procesadores de ese nodo tipo itaniumb, con un tiempo solicitado de 4 horas y 1 GB de RAM:

send_siesta job1 1 4:itaniumb 04:00:00 1

Mandamos Siesta con el input job3.fdf a 2 nodos, 4 procesadores en cada nodo, con un tiempo solicitado de 60 horas, 8 GB de RAM y que se ejecute después del trabajo 1234.arinab:

send_siesta job3 2 4 60:00:00 8 ``-W depend=afterany:1234''

Mandamos Siesta con el input job3.fdf a 1 nodo y 4 procesadores en cada nodo, con un tiempo solicitado de 400 horas, 15 GB de RAM y que nos envíe un email al inicio y final del cálculo a la direción especificada.

send_siesta job3 1 4 400:00:00 15 ``-m be -M mi.email@ehu.es''

 

qsub interactivo

Ejecutamos

 qsub

sin argumentos y respondemos a las preguntas.

qsub tradicional

También existe la posibilidad de mandar siesta de la forma clásica, donde el usuario se créa su script de PBS. Hay ejemplos en este link. Hay que añadir al script la orden:

/software/bin/siesta/siesta_mpi < input.fdf > log.out

Monitorización de los cálculos

Para facilitar el seguimiento y/o control de los cálculos, existen las suiguientes herramientas si ha sido enviado usando send_siesta o qsub en interactivo:

  • remote_vi Nos enseña con el gvim el *.out del cálculo de siesta.
  • remote_xmakemol Nos enseña con el xmakemol el *.ANI del cálculo de siesta.
  • remote_qmde Nos enseña con el xmgrace la evolución de la energía respecto al tiempo de un cálculo de Dinámica Molecular .

El uso de todas estas herramientas es muy similar, hay que ejecutarlas seguido el identificador que el cálculo tiene en el sistema de colas. Ejemplos para monitorizar el trabajo con identificador 3465:

remote_vi 3465
remote_xmakemol 3465
remote_qmde 3465

Cómo enviar Orca

Comando send_orca

El comando send_orca envía los cálculos orca de un modo sencillo al sistema de colas.

Recomendamos el uso del comando send_orca. Este comando preparará script de TORQUE y lo enviará a la cola. El fichero de out (*.out) se mantendrá en el /scratch del nodo de remoto, pero send_orca envía el trabajo de tal menera que puede ser visualizado con las herramientas remote_viremote_molden (ver más abajo).

modo de uso del comando send_orca es el siguiente:

send_orca trabajo cola_o_tiempo nim_nodes num_proc [mem] [opciones de TORQUE]

donde:

  • trabajo: Es el nombre del input de orca sin la extensión (*.inp).
  • cola o tiempo: Se puede indicar la cola a la que se quiere mandar el cálculo o el tiempo en formato (hh:mm:ss).
  • num_nodes: El número de nodos que se quiere usar-
  • num_proc: El número de procesadores que se quiere usar por nodo. Es posible añadir propiedades de los nodos, por ejemplo 8:xeon
  • mem:  la memoria en GB.
  • [opciones de TORQUE]: Opciones avanzadas que se quieren pasar al gestor de colas TORQUE.

Ejemplos

send_orca h2o p_slow 1 8

Enviará el trabajo h2o en  1 nodo y 8 procesadores a la cola p_slow con los valores de memoria predeterminados en este caso 7.2Gb (nproc*900mb).

send_orca h2o p_slow 2 8 20

Enviará el trabajo h2o en dos nodos y 8 procesadores en cada uno  a la cola p_slow con 20gb de memoria RAM.

send_orca h2o 23:00:00 16:xeon 4 ``-m be -M niri@ehu.es -W depend=afterany:4827''

Enviará el trabajo h2o en 2 nodos Xeony 8 procesadoeres en cada uno,  con 4gb de RAM. El tiempo solicitado son 23 horas, y nos enviará un email al inicio y final del cálculo. Por otra parte este trabajo no empezará hasta que termine el trabajo 4827.

Seguimiento del trabajo

Existen las herramietas remote_viremote_molden, que permiten ver el fichero .log o mostrar la estructura con Molden. Para ello hay que usarsend_gaussianqsub interactivo. Su uso el el siguiente:

remote_vi 2341
remote_molden 2341

o

remote_vi 2341.arina
remote_molden 2341.arina

donde 2341(.arina) es el identificador del trabajo en la cola.

Cómo mandar Espresso

send_espresso

Para lanzar al sistema de colas trabajos de Quantum Espresso existe la utilidad send_espresso. Al ejecutarlo, muestra la sintaxis del comando, que se resume a continuación:

send_espresso input Executable Nodes Procs_per_node Time Mem [``Otherqueue options'' ]
Input Nombre del input de espresso sin extensión
Executable Nombre del programa de espresso que se quiere usar: pw.x, ph.x, cp.x,…
Nodos Número de nodos a los que se quiere mandar el cálculo
Procs_per_node: Número de procesadores por nodo
Time: Tiempo solicitado a la cola, formato hh:mm:ss
Mem Memoria en GB y sin especificar la unidad
[“Otras opciones de Torque”] Existe la posibilidad de pasar más variables al sistema de colas. Ver ejemplos más abajo

Ejemplos

Mandamos Espresso (binario pw.x) con el input job1.in a 1 nodo, 4 procesadores de ese nodo, con un tiempo solicitado de 4 horas y 1 GB de RAM:

send_espresso job1 pw.x 2 4 04:00:00 1

Mandamos espresso (car-parrinello) con el input job2.in a 2 nodos, 8 procesadores en cada nodo, con un tiempo solicitado de 192 horas, 8 GB de RAM y que se ejecute después del trabajo 1234.arina:

send_espresso job2 cp.x 2 8 192:00:00 8 ``-W depend=afterany:1234''

Mandamos espresso (binario ph.x) con el input job3.in a 8 nodos y 8 procesadores en cada nodo, con un tiempo solicitado de 200:00:00 horas, 64 GB de RAM (global) y que nos envíe un mensaje de correo al inicio y final del cálculo a la dirección especificada.

send_espresso job3 ph.x 8 8 200:00:00 64 ``-m be -M mi.email@ehu.es''

El comando send_espresso copia el contenido del directorio desde el que se lanza al /scratch o /gscratch -si se usan 2 o más nodos. Es allí donde realiza el cálculo.

Cómo usar creando tu propio script para Torque

Los ejecutables de Espresso se encuentran instalados en /software/bin/espresso. Por ejemplo, para ejecutar pw.x en las colas usar:

source /software/Espresso/compilervars.sh
/software/Espresso/bin/pw.x -npool ncores < input_file > output_file

En la opción -npool ncores hay que sustituir ncores por el número de cores que se va a usar, esto mejora la velocidad de ejecución del cálculo. Si se solicitan más de un core se ejecuta automáticamente en paralelo.