Todas las entradas de: admin

Espresso

Información general

opEn-SourceP ackage for Research in Electronic Structure, Simulation, and Optimization

Versión 6.1  del paquete de programas de cálculo ab-initio de DFT con pseudo-potenciales (ultrasoft y PAW-augmented wave method), desarrollado en DEMOCRITOS National Simulation Center of the Italian INFM.

Consta de un programa de estructura electrónica con base de ondas planas (PW), un programa de dinámica molecular basada en primeros principios (FPMD) y en Car-Parrileno (CP). Incluye también un programa para generar pseudopotenciales y una interfaz gráfica para PW. Existe la versión en serie y la paralela.

Cómo usar

[intlink id=»4493″ type=»post»]Ver apartado como enviar espresso.[/intlink]

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_espresso):

  • remote_vi: Nos enseña con el editor gvim el *.out del cálculo de espresso.
  • myjobs: Durante la ejecución nos muestra el uso de cpu y memoria (SIZE) de nuestro trabajo, útil para conocer la memoria RAM a solicitar en trabajos posteriores similares.

Benchmark

Presentamos los datos de unos pequeños benchmark de pw.x y ph.x en las máquinas del servicio. Los mejores nodos son los Xeon y escala perfectamente a 32 cores. Parece que se nota que la red de comunicación de los xeon es mejor.

Tabla 1: Tiempos de ejecución de pw.x (versión 4.2.1).
System 8 cores 16 cores 32 cores
Xeon 1405 709 378
Itanium2 2614 1368 858
Opteron 2.4 4320 2020 1174
Core2duo 2.1
Tabla 2: Tiempos de ejecución de ph.x (versión 4.2.1)
System 8 cores 16 cores 32 cores
Xeon 2504 1348 809
Itanium2 2968 1934 1391
Opteron 2.4 6240 3501 2033
Core2duo 2.1

Más información

Página de ESPRESSO.

Documentación en línea.

Wiki de ESPRESSO.

STAR-CCM+

Información general

StarCCM+ es un programa de Dinámica de Fluídos.  La versión actual es la 14.04.013. En la arquitectua Itanium la última versión soportada e instalada es la 6.04.

Si se ejecuta Starccm+ en cualquiera de los servidores se abre la aplicación gráfica, en los nodos de cálculo se ha de lanzar mediante [intlink id=»19″ type=»post»]el sistema de colas[/intlink] (sin interfaz gráfica) y realizará el cálculo sin interfaz gráfica.

También esta disponible la aplicación Starview.

Cómo ejecutar

En modo interactivo (interface gráfica)

Los usuarios deberán cerciorarse el poder ejecutar una aplicación gráfica de los servidores del Servicio en sus ordenadores personales. Esto se explica [intlink id=»48″ type=»post»]en la guía de acceso[/intlink] al servicio.

Para abrir la interfaz gráfica de starccm+o starview+ usar:

starccm+
starview+

En el sistema de colas

Para mandar trabajos al [intlink id=»19″ type=»post»]sistema de colas[/intlink] basta ejecutar el comando [intlink id=»233″ type=»post»]qsub en interactivo[/intlink]

qsub

que os preguntará lo necesario para hacerlo, en la primera pregunta la opción 2 es lanzar un cálculo de Starccm+. Este comando selecciona automáticamente los nodos Xeon, los de mejor rendimiento.

Si queréis usar directamente un script para enviarlo a las colas debéis ejecutar en él:

/software/bin/starccm+ -run macro_file.java input_file.sim > log_file.log

con los nombres correspondientes para los ficheros de entrada y el de log. «-run macro_file.java» es opcional. En  este link hay un script de ejemplo, os recomendamos usarlo.  Se tiene licencia de cálculo intensivo para lanzar trabajos en 8 cores en paralelo.

Monitorización de los cálculos

Para monitorizar de forma rápida la convergencia de un cálculo que se está ejecutando en los nodos de cálculo con el identificador de trabajo 1234.arina, por ejemplo, podéis usar el comando:

starccm+_plot 1234

Para abortar limpiamente un cálculo tras la iteración en curso que se está ejecutando, con el identificador de trabajo 1234.arina por ejemplo, podéis usar el comando:

starccm+_abort 1234

También podéis conectaros al nodo a través de la aplicación gráfica, el comando «ni» muestra el nodo en el que se ejecuta vuestro trabajo.

Benchmark

Presentamos los resultados de un benchmark realizado en los xeones de 8 cores del Servicio (procesador E5520 a 2.27 GHz) para analizar el rendimiento de STAR-CCM+, se usó la versión 8.02. Se midieron los tiempos medios por iteración (segundos) en función del número de cores usado.

 

8 cores 16 cores 32 cores
Tiempo por iteración 32.8 14.6 7.6
Aceleración ideal 1 2 4
Aceleración 1 2.2 4.3
Eficiencia 1 112 % 108 %

Primero observamos que STAR-CCM+ escala muy bien cuando aumentamos el número de cores, multiplicar por 2 el número de procesadores reduce a la mitad el tiempo por iteración. De hecho, incluso en este benchmark, observamos un comportamiento superlineal al conseguir eficiencias por encima del 100 %.

Más información

Página web de CD-Adapco.

La interfaz gráfica trae un manual muy completo.

Librerías FFTW

Librerías Fastest Fourier Transform in the West para relizar todo tipo de transformadas de Fourier.

Está instalada la versión 3.3.3 en /software/fftw. Se han compilado con varios tipos (threads, simple precission,etc)

Para linkarlas se debe usar

-L/software/fftw -lfftw3

Ante cualquier duda consultar a los técnicos.

Más información en la página web de FFTW.

Librerías MPI

Información general

Las Librerías MPI son las más utilizadas a la hora de realizar cálculos distribuidos. Existen numerosas variedades. En el servicio tenemos HP-MPI. MPIbull2 … Las últimas versiones disponibles son IntelMPI 4.0.3, MPIbull2 1.3, hpMPI 2.02, openMPI 1.4 y mvapich2 1.5. Puedes de manera gráfica la disponibilidad en [intlink id=»2768″ type=»post»]esta tabla[/intlink] .

Consulta con los técnicos ante cualquier duda o para solicitar más información.


Librerías instaladas por defecto

Las versiones instaladas por defecto en estos momentos son:

  • En los nodos Itanium (Arina) mpibull2.
  • En los nodos Opteron (Maiz) Intelmpi.
  • En los Xeon (Guinness-Katramila) Intelmpi.
  • Intelmpi en Pendulo.

Librerías intelMPI

Están disponibles en los nodos xeon y opteron (Arina y maiz). Si no están por defecto se pueden cargar ejecutando

source /software/intel/impi_latest/bin64/mpivars.sh

Para compilar con los compiladores de Intel Fortran, C y C++ ejecutar mpiifort, mpiicc e mpiicpc respectivamente. Para compilar con los compiladores de GNU emplear mpif90, mpicc e mpiCC.

Librerías MPIbull2

Están disponibles en los nodos xeon e itanium (Guinness y Arina). Si no están por defecto se pueden cargar ejecutando

source /opt/mpi/mpibull2-1.3.9-18.s/share/mpibull2.sh

Para compilar con los compiladores de Intel Fortran, C y C++ ejecutar mpif90, mpicc e mpiCC.

Librerías hpMPI

Están disponibles en los nodos itanium e opteron (Arina y Maiz). Si no están por defecto se pueden cargar ejecutando

export PATH=/opt/hpmpi/bin:$PATH

Para compilar con los compiladores de Intel Fortran, C y C++ ejecutar mpif90, mpicc e mpiCC.

Librerías openMPI

Están disponibles en los nodos xeon (Guinness) y Pendulo. Están instaladas en /software/openmpi. Para usar estas librerías hay que especificar el path completo, por ejemplo:

/software/openmpi/bin/mpif90

Para compilar con los compiladores de Intel Fortran, C y C++ ejecutar los binarios mpif90, mpicc e mpiCC.

Librerías mvapich2

Están disponibles en los nodos xeon (Guinness). Están instaladas en /software/mvapich2. Para usar estas librerías hay que especificar el path completo, por ejemplo:

/software/mvapich2/bin/mpif90

 

Para compilar con los compiladores de Intel Fortran, C y C++ ejecutar los binarios mpif90, mpicc e mpiCC.

Compiladores de Intel

Información general

Recomendamos en general, pero encarecidamente en los nodos Itanium2, los compiladores de Intel sobre los de GNU. En los itanium2 hemos llegado a acelerar un programa en 50 veces con solo compilarlo con el de Intel.

Hemos realizado un manual sobre como compilar (pdf) en las máquinas del servicio y como usar de forma sencilla todos los nodos de cálculo disponibles en el servicio. Es muy recomendable leerlo.

Para más información o si tienes dudas no dudes en preguntar a los técnicos.

Compiladores instalados por defecto

  • En los nodos Itanium compiladores Intel 11.1 Fortran (ifort), C (icc) eta C++ (icpc).
  • En los nodos Xeon compiladores Intel  15.0 Fortran (ifort), C (icc) eta C++ (icpc).

Cómo ejecutar

Los ejecutables de fortran, C y C++ son ifort, icc, icpc.

Más información

Para más información ejecutar, por ejemplo, ifort -help o similar para compilador o preguntar a los técnicos.

Manual del lenguaje Fortan

Manual del compilador Fortran

Manual del compilador de C

Librerías Matematicas de Intel (MKL)

Información general

Estas librerías incluyen las librerías LAPACK y BLAS, pero también transformadas de Fourier, PARDISO (resuelve grandes sistemas de equaciones lineales), funciones matemáticas (Vector Math Library-VML) y funciones estadísticas (Vector Statistical Library-VSL). Están disponibles en todas las máquinas del servicio.

Para más información o si tienes dudas no dudes en preguntar a los técnicos.

 

Cómo linkarlas

Si no sabes exactamente como linkarlas en las diferentes arquitecturas, por favor, consulta con los técnicos.

 

Librerías instaladas por defecto

Las versiones instaladas por defecto son:

  • 11.1 en los nodos Itanium2 (/opt/intel/Compiler/11.1/073/mkl/lib/64).
  • 15.0 en los nodos Xeon (/software/intel/composerxe/mkl/lib/intel64).
  • 15.0 en Péndulo (/software/intel/composerxe/mkl/lib/intel64).

 

Más Información

Guía del usuario de las MKL 10.1

Manual de las MKL 10.1

Manual de las VSL

Información en línea.

Los recursos materiales y humanos están a disposición de empresas y agentes externos a la universidad. Para más información [intlink id=»154″ type=»page»]consultar a los técnicos del Servicio[/intlink].

Tarifa Interna

Información general

La tarifa interna se aplica a investigadores y centros de la UPV/EHU. Incluye servicio técnico y de aplicaciones. Estas tarifas estarán vigentes desde el 15 de Septiembre de 2021 hasta el 15 de Septiembre de 2022.

Tarifas por uso de CPU

La tarifa para el grupo de investigación será de 0.005 €/hora y core

Tarifa por almacenamiento

Se facturará por tener datos en Arina. Para establecer la tarifa se han  seguido los siguientes criterios:

  • Se facturará menos a los que realmente usen el servicio, es decir, usan en el servicio los datos almacenados en el mismo. Por lo tanto, se establece una factura dependiente del tiempo de cálculo consumido al final del año por el grupo.
  • No se factura por debajo de 3 GB por usuario.
  • Se facturará cada mes sobre la media de disco usado ese mes.
  • Se emplearán los precios por GB de la siguiente tabla, que tienen en cuenta el tiempo consumido en el servicio.
Tarifas por GB extra almacenado cada mes
Rango de uso de CPU Tarifa de Almacenamiento
(en días al año) (€/Gb) al mes
2500< cpu 0.1
100< cpu <2500 0.5
1< cpu <100 1.0
0< cpu <1 1.5

Tarifa para empresas

Tarifa por CPU

Tarifa para organismos privados. La tarifa por el uso de los recursos computacionales es de 0.016 €/hora y por core (cpu simple) (sin IVA). Incluye soporte técnico de para tareas y problemas comunes. No está incluido el almacenamiento de datos, ni servicios especializados de los técnicos, que dependerá del tipo de asistencia que se requiera, por lo que se deberá describir el proyecto a realizar para establecer un presupuesto.

Tarifa por almacenamiento

Se facturará por tener datos en Arina siguiendo los siguientes criterios:

  1. Se facturará menos a los que realmente usen el servicio, es decir, usan en el servicio los datos almacenados en el mismo. Por lo tanto se establece una factura dependiente del tiempo de cálculo consumido al final del año por el grupo.
  2. No se factura por debajo de 3 GB.
  3. Se facturará por meses sobre la media de disco usado en cada mes.
  4. Se emplearán los precios por GB, usando los precios establecidos en la siguiente tabla, que tienen en cuenta el tiempo consumido en el servicio (sin IVA).

Tarifas por GB extra almacenado cada mes que se aplicarán en función del uso del servicio.
Rango de uso de CPU Tarifa de Almacenamiento
(en días al año) (Euros/Gb) al mes
2500< cpu 0.1
100< cpu <2500 0.5
1< cpu <100 1.0
0< cpu <1 1.5

IVA no incluído.

Solicitar tiempo de cálculo

Se debe de solicitar tiempo de cálculo en Arina para poder calcular. El tiempo de cálculo podrá ser solicitado por cualquier profesor o investigador contratado por la UPV/EHU u ente externo (instituciones públicas o privadas, empresas,…). Los investigadores de la UPV/EHU deberán rellenar el formulario solicitando el tiempo de CPU que creen que van a necesitar para la convocatoria en curso, año 2010.
Seguir leyendo Solicitar tiempo de cálculo

Qsub interactivo

Si se ejecuta simplemente qsub sin añadir ningúna 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. Se puede usar con cualquier ejecutable pero también hay una lista de programas predefinidos (vasp, wrf, adinit, gaussian, nwchem …) de los cuales además se realizan comprobaciones como que los ficheros necesarios están presentes. Si se quiere añadir alguno más a la lista contactar con lo técnicos. Las respuestas son almacenadas como respuestas por defecto para la siguiente vez.

De acuerdo a los parámetros definidos por el usuario, el sistema de colas encajará cada trabajo en la cola pertinente. En caso de que algun parametro no sea definido por el usuario, TORQUE tiene determinados unos por defecto, que pueden no adecuarse al trabajo que mandamos por lo que es muy recomendable definirlos.

Para poder seguir correctamente las preguntas del qsub interactivo, os recomendamos que reviseis el apartado otras directivas.

Qsub tradicional

Ejecutar en la línea de comandos
qsub script_file

donde el archivo script_file contiene las directivas para el gestor de colas TORQUE y los comandos a ejecutar para poner el trabajo en marcha. En las siguientes secciones se detallan ciertos scripts. Una vez mandado el trabajo a la cola, obtendremos en pantalla el número de identificación del proceso, por ejemplo:

159.lgua00

Tras la ejecución, comprobar el contenido del archivo script.e159, en este caso para verificar los errores. La salida estándar del programa está en scrip.o159.

Trabajo en serie
En los trabajos en serie es altamente recomendable que se trabaje usando el espacio de disco local, la partición /scratch situada en cada nodo. El proceso de lectura y escritura es más rápido, por lo que el propio trabajo se ve beneficiado. Además, no se usa la red (NFS) en la lectura/escritura, por lo que el resto de los trabajos en otros nodos también irán más rápido y se evita saturar la red.

Los scripts se envían al sistema de colas con el comando

qsub script_file

o se puede usar el modo interactivo

qsub

Para seleccionar el tipo de arquitectura o nodo ver otras directivas.

Una plantilla de script que ejecuta el programa a.out es

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

#Nuestro directorio de scratch
scrt=/scratch/$USER/$PBS_JOBID

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

#Nos movemos de directorio
cd $scrt

#Ejecutamos el programa
./a.out

#Movemos los archivos finales a nuestro home
outdir=escoger_nombre
mkdir $PBS_O_WORKDIR/$outdir
mv -f $scrt/* $PBS_O_WORKDIR/$outdir

#Borramos el directorio
rmdir $scrt

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

nodes: [opcional] Se puede usar para selecionar el nodo de cálculo (ejemplo: node=cn14).

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).

El resto de líneas que comienzan con # son comentarios.

En el script hay que sustituir escoger_nombre por el del directorio donde queremos guardar los resultados. La variable $USER devuelve el nombre del usuario, $PBS_O_WORKDIR el directorio de trabajo desde donde se ejecuta el comando qsub y $PBS_JOBID el número de identificación del trabajo.

Si el programa a.out no está en un directorio del $PATH, e.g. /usr/local/bin sino en nuestro directiorio es necesario usar ./a.out .

Ejemplo de trabajo en serie.

Tras la ejecución, comprobar el contenido del archivo script.eXXX para verificar los errores.

Las órdenes para PBS se pueden indicar directamente en el comando, en vez de en el script, usando a la hora de enviar el trabajo

qsub -l nodes=[name],mem=[val],walltime=[val] script

Trabajo en paralelo
Es recomendable lanzar los trabajos a 4 procesadores o 8 procesadores por nodo (ppn=4 o ppn=8), lo cual reduce los tiempos de espera. También es altamente recomendable que los trabajos escriban localmente en los nodos cuando sea posible.

Si el trabajo corre en un único nodo o, corriendo en más nodos, los microprocesadores no comparten archivos, el trabajo puede escribir sobre el disco local. Los scripts se envían al sistema de colas con el comando

qsub script_file

o se puede usar el modo interactivo

qsub

Para seleccionar el tipo de arquitectura o nodo ver otras directivas.

Una plantilla de script que ejecuta el programa a.out en paralelo es

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

#Nuestro directorio de scratch
scrt=/scratch/$USER/$PBS_JOBID

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

#Nos movemos de directorio
cd $scrt

#Ejecutamos el programa
mpirun a.out

#Movemos los archivos finales
outdir=escoger_nombre
mkdir $PBS_O_WORKDIR/$outdir
mv -f $scrt/* $PBS_O_WORKDIR/$outdir

#Borramos el directorio
rmdir $scrt

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 hay que sustituir escoger_nombre por el del directorio donde queremos guardar los resultados la variable $USER devuelve el nombre del usuario, $PBS_O_WORKDIR el directorio de trabajo desde donde se ejecuta el comando qsub y $PBS_JOBID el número de identificación del trabajo.

Ejemplo de trabajo en paralelo usando el disco local /scratch .

Si el trabajo va a correr en varios nodos y los procesos comparten archivos han de ejecutarse desde nuestro /gscratch, que es un sistema de archivos de alto rendimiento compartido por todos los nodos (ver coniguración). El script que realiza esto es

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

#Nuestro directorio de scratch
scrt=/gscratch/$USER/$PBS_JOBID

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

#Nos movemos de directorio
cd $scrt

#Ejecutamos el programa
mpirun a.out

#Movemos los archivos finales
outdir=escoger_nombre
mkdir $PBS_O_WORKDIR/$outdir
mv -f $scrt/* $PBS_O_WORKDIR/$outdir

#Borramos el directorio
rmdir $scrt

Ejemplo de trabajo en paralelo usando gscratch.

Tras la ejecución, comprobar el contenido del archivo script.eXXX para verificar los errores.

Las órdenes para PBS se pueden indicar directamente en el comando, en vez de en el script, usando a la hora de enviar el trabajo

qsub -l nodes=[val]:ppn=[val],mem=[val],cput=[val] script

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 [intlink id=»233″ type=»post»]qsub en interactivo[/intlink] 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 [intlink id=»233″ type=»post»]qsub interactivo[/intlink].

qsub tradicional

Podemos construir nuestro propio script para Torque. [intlink id=»237″ type=»post» target=»_blank»]En este enlace[/intlink] 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.

Servicios

El Servicio General dispone de hardware propio, que está disponible para el uso de la comunidad científica. Campos y aplicaciones posibles en las que estos recursos pueden ser de utilidad son:

  • Simulación.
    • Simulación de materiales y moléculas a nivel atómico con dinámica molecular.
    • Quantum montecarlo.
    • Métodos de estructura electrónica en general.
    • Modelización de biopolímeros (proteinas, DNA …) a nivel estructural y/o dinámica molecular.
    • Simulación de materiales a nivel macroscópico difusión de calor, resistencia al esfuerzo,…
    • Simulaciones metereológicas y de fluidos.
  • Aplicaciones de Bioinformática.
  • Renderizado de imágenes.
  • Tratamiento de bases de datos.
  • Cálculos que por sus características se necesite o recomiende un ordenador de potencia superior, o que sin tal necesidad, sea conveniente que residan en servidores.
  • Simulación de mercados bursátiles, gestión de empresas,…
  • Cálculo paralelo.

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.

Cómo mandar Turbomole

send_turbo

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

send_turbo "EXEC and Options" JOBNAME TIME[or QUEUE] PROCS[property]  MEM [``Otherqueue options'' ]

  • EXEC: Nombre del programa de turbomole que se quiere usar.
  • JOBNAME: Nombre del input (normalmente control).
  • PROCS: Número de procesadores.
  • TIME[or QUEUE]: Tiempo solicitado a la cola, formato hh:mm:ss (o nombre de la cola).
  • 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

Para mandar Turbomole (binario jobex) con el input control a 1 nodo, 8 procesadores de ese nodo con un tiempo solicitado de 4 horas y 1 GB de RAM ejecutar:

send_turbo jobex control 04:00:00 8 1

Para mandar Turbomole (jobex -ri) con el input control 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_turbo jobex -ri control 192:00:00 16 8 ``-W depend=afterany:1234''

El comando send_turbo 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.

Lista de Distribución

La lista sirve para avisar a los usuarios sobre incidencias de las máquinas e información de interés. Nos gustaría que también fuera un foro de ayuda para los problemas y/o dudas que pueda generar el uso del del servicio (tanto de hardware como de software). Así, además de los técnicos, los usuarios también podrán tener conocimiento de los problemas de otros usuarios, que muchas veces coinciden con los propios.

Seguir leyendo Lista de Distribución

NWchem

Información general

Nwchem es un paquete de química computacional con varios métodos para calcular propiedades de sistemas moleculares y periódicos, usando descripciones mecánico-cuánticas estándar para las funciones de onda o la densidad electrónica. Además, puede realizar simulaciones de dinámica molecular y QM/MM. La versión que está instalada es la versión 5.1.

Como mandar NWchem

Ver la sección del sistema de colas [intlink id=»222″ type=»post»]como mandar trabajos NWchem[/intlink].

Más información

Nwchem home page.

VASP

Información general

Vienna Ab-initio of Simulation Package

Versión 5.4.4 del programa de cálculo ab-initio de DFT con base de ondas planas y pseudo-potenciales (ultrasoft y PAW-augmented wave method), desarrollado en la Universidad de Viena. Permite realizar relajaciones atómicas (dinámica molecular). Incluye las herramientas VTST.

Se requiere licencia.

Cómo usar

Para ejecutar VASP en paralelo basta con ejecutar el comando

/software/bin/vasp

Se encuentra instalado el software de visualización [intlink id=»1353″ type=»post»]p4vasp[/intlink], [intlink id=»5514″ type=»post»]XCrySDen[/intlink]. Para transformar los ficheros y poder ser leidos se puede usar XfsConvert ejecutando

v2xsf

Monitorizar cálculos

Se puede comprobar la convergencia de un cálculo en marcha con el comando

remote_vi JOB_ID

que nos abrirá los ficheros OSZICAR y OUTCAR además de dibujarnos la evolución de la energía y su variación. Es necesario conectarse con ssh -X o usar X2GO para que se abran las ventánas con los gráficos.

Más información

VASP home page y manuales.

VTST tools.

Tarifas para organismos públicos

Tarifa por CPU

La tarifa por el uso de los recursos computacionales es de 0.011 euros por hora y por core (cpu simple). Incluye soporte técnico de para tareas y problemas comunes. No está incluido el almacenamiento de datos, ni servicios especializados de los técnicos, que dependerá del tipo de asistencia que se requiera, por lo que se deberá describir el proyecto a realizar para establecer un presupuesto. Abajo se puede ver el listado de OPIs.

Tarifa por almacenamiento

Se facturará por tener datos en Arina siguiendo los siguientes criterios:

Se facturará menos a los que realmente usen el servicio, es decir, usan en el servicio los datos almacenados en el mismo. Por lo tanto se establece una factura dependiente del tiempo de cálculo consumido al final del año por el grupo.
No se factura por debajo de 3 GB.
Se facturará por meses sobre la media de disco usado en cada mes.
Se emplearán los precios por GB, usando los precios establecidos en la tabla 9, que tienen en cuenta el tiempo consumido en el servicio.

Rango de uso de CPU Tarifa de Almacenamiento
(en días al año) (Euros/Gb) al mes
2500< cpu 0.1
100< cpu <2500 0.5
1< cpu <100 1.0
0< cpu <1 1.5

IVA no incluído.

Organismos Públicos de Investigación (OPIs) según el MINECO
Organismos Públicos de Investigación dentro de los Agentes de la Red Vasca de Ciencia, Tecnología e Innovación

La Dirección de los SGIker ha aprobado incluir en el grupo de OPIs a las Universidades públicas  del Estado y sus respectivos Hospitales Universitarios (si los tuviesen), mientras que las privadas quedarían fuera de este grupo.

Recursos y su administración

Las tareas asignadas al Servicio relacionadas con el mantenimiento y buen funcionamiento del cluster son:

  • Administración de los recursos computacionales (cuentas, colas, seguridad, …)
  • Control y optimización del rendimiento de los recursos físicos.
  • Formación de los usuarios en el manejo eficiente de los recursos.
  • Instalación y actualización de software de sistema, otras herramientas y aplicaciones.
  • Benchmarking y optimización del software.

Soporte Estratégico

  • Seguimiento de los desarrollos más relevantes en el campo de la computación científica, con vistas a la mejora del Servicio.
  • Asesoría sobre la adquisición de nuevo equipamiento de cálculo científico, bien para el propio Servicio, o para investigadores o grupos de investigadores de la institución que lo solicite.
  • Gestión de la adquisición de software para uso por los grupos de investigación.
  • Racionalización del software existente en la EHU/UPV.
  • Asesoría sobre la preparación de solicitudes para convocatorias públicas competitivas de adquisición de equipamiento de cálculo científico así como, sobre las alianzas de investigadores más efectivas para la institución, en dichas convocatorias.

Consultoría y formación

  • Recopilación y diseminación entre los investigadores de las «mejores prácticas» en computación científica, a través de cursos, seminarios, y otros mecanismos adecuados para ese fin.
  • Asistencia para diseñar o mejorar códigos, asesorando a los usuarios en la utilización de librerías, compiladores, etc.
  • Ayuda en el uso eficiente de las aplicaciones, incluyendo en su caso asesoría sobre paralelización y estrategias de manejo de datos.
  • Consultoría sobre la optimización de los recursos informáticos que posea un grupo de investigación.
  • Ayuda en la identificación las necesidades de Software/Hardware para solucionar problemas científicos específicos.
  • TB-LMTO

    Información general


    Tight Binding Linear Muffin-Tin Orbital

    Versión 4.6. del programa de cálculo ab-initio de DFT basado en el método linear muffin-tin orbital (LMTO). Es software libre pero requiere de la autorización del autor.

    Como usar


    Para ejecutar los diversos programas usar por ejemplo:

    /software/bin/lm.run

    Para poder compilarlo para itanium ha sido necesario reducir la optimización y es sensiblemente más lento que en los opteron y Péndulo. Es un código bastante antiguo y da problemas de memory overflow debido a la gestión particular que hace de la memoria y puede ser necesario recompilarlo para tú sistema.

    Benchmark

    Presentamos los datos de un pequeño benchmark donde se muestra el comportamiento de los itanium mencionado.

    System Segundos
    Itanium 1225
    Opteron 450
    Core2Duo 332

    Más información

    Página de TB-LMTO.

    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. [intlink id=»244″ type=»post»]Más información sobre estas opciones[/intlink]

    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 [intlink id=»233″ type=»post»]qsub interactivo[/intlink].

    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 [intlink id=»3849″ type=»post»]Terachem[/intlink] 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 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 [intlink id=»233″ type=»post»]qsub interactivo.[/intlink]

    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.