Ansys

From CC Doc
Jump to navigation Jump to search
This site replaces the former Compute Canada documentation site, and is now being managed by the Digital Research Alliance of Canada.

Ce site remplace l'ancien site de documentation de Calcul Canada et est maintenant géré par l'Alliance de recherche numérique du Canada.

This page is a translated version of the page Ansys and the translation is 91% complete.
Outdated translations are marked like this.
Other languages:

Ansys est une suite logicielle pour la conception 3D et la simulation. La suite comprend des applications comme Ansys Fluent et Ansys CFX.

Licence

La suite Ansys est hébergée sur nos grappes, mais nous n'avons pas une licence qui permet un accès généralisé. Toutefois, plusieurs établissements, facultés et départements possèdent des licences qui peuvent être utilisées avec nos grappes; vérifiez l'aspect légal de l'utilisation de cette licence. En ce qui a trait à l'aspect technique, nos nœuds de calcul doivent pouvoir communiquer avec votre serveur de licence. Si ce n'est pas déjà fait, notre équipe technique coordonnera ceci avec votre gestionnaire de licence. Quand tout sera en place, vous pourrez charger le module Ansys qui localisera de lui-même la licence. En cas de difficulté, communiquez avec le soutien technique.

Configurer votre propre fichier de licence

Notre module Ansys cherche l'information sur la licence à différents endroits, dont votre répertoire /home. Si vous avez votre propre serveur de licence, entrez les renseignements pour y accéder dans le fichier $HOME/.licenses/ansys.lic selon le format suivant :

File : ansys.lic

setenv("ANSYSLMD_LICENSE_FILE", "port@hostname")
setenv("ANSYSLI_SERVERS", "port@hostname")


Run the solver for this many steps

/solve/iterate 1000

Licence Grappe ANSYSLMD_LICENSE_FILE ANSYSLI_SERVERS Remarques
CMC beluga 6624@10.20.73.21 2325@10.20.73.21 aucune
CMC cedar 6624@172.16.0.101 2325@172.16.0.101 aucune
CMC graham 6624@199.241.167.222 2325@199.241.167.222 aucune
CMC narval 6624@10.100.64.10 2325@10.100.64.10 aucune
SHARCNET beluga/cedar/graham/gra-vdi/narval 1055@license3.sharcnet.ca 2325@license3.sharcnet.ca aucune

Si vous avez obtenu une licence de CMC, vous devez faire parvenir le nom d'utilisateur associé à votre compte avec l'Alliance à <cmcsupport@cmc.ca>, autrement la licence ne fonctionnera pas. Pour connaître le nombre de cœurs que vous pouvez utiliser avec une licence CMC, voyez les sections Other Tricks and Tips des guides Ansys Electronics Desktop et Ansys Mechanical/Fluids.

Serveurs de licence locaux

Pour que nos nœuds de calcul puissent communiquer avec votre serveur de licence, des modifications doivent être apportées des deux côtés. Pour ce faire, obtenez de l'administrateur de votre serveur de licence les renseignements suivants : 1. le nom complet (hostname) de votre serveur de licence Ansys; 2. le port flex pour Ansys (habituellement 1055); 3. le port d'interconnexion pour votre licence Ansys (habituellement 2325); 4. le port statique (static vendor port) pour votre licence Ansys (spécifique au site). Votre administrateur doit vouloir ouvrir le pare-feu pour ces trois ports pour que les tâches Ansys exécutées sur nos grappes puissent obtenir une licence. Faites parvenir les renseignements demandés au soutien technique et indiquez la ou les grappes que vous voulez utiliser (Béluga, Cedar, Graham/gra-vdi, Narval ou Niagara).

Vérifier l'utilisation de la licence

Ansys offre l'outil lmutil pour vérifier les détails de l'utilisation de votre licence. Auparavant, assurez-vous que le fichier ansys.lic est configuré et que vous avez chargé un module Ansys. 

[name@server ~]$ module load ansys
[name@server ~]$ $EBROOTANSYS/shared_files/licensing/linx64/lmutil lmstat -c $ANSYSLMD_LICENSE_FILE -S ansyslmd

Compatibilité des versions

Comme mentionné par Ansys dans Platform Support, la version courante (2021R2) a été testée pour lire et ouvrir les bases de données des cinq versions précédentes. De plus, certains produits peuvent lire et ouvrir des bases de données de versions antérieures à Ansys 18.1.

Soumettre des tâches en lot sur nos grappes

Plusieurs implémentations MPI incluses dans la suite Ansys permettent le calcul parallèle, mais aucune n'est compatible avec l'ordonnanceur Slurm (voir Exécuter des tâches). Pour cette raison, il faut utiliser des directives particulières à chaque paquet Ansys pour lancer une tâche parallèle. Vous trouverez ci-dessous quelques scripts de soumission de tâches. Si ces scripts ne s'appliquent pas dans votre cas, communiquez avec le soutien technique.

Ansys Fluent

La procédure suivante est habituellement utilisée pour exécuter Fluent sur une de nos grappes :

  1. Sur votre ordinateur, préparez votre tâche avec Fluent du Ansys Workbench jusqu'au point où les calculs seraient exécutés.
  2. Exportez le fichier de cas avec File > Export > Case… ou localisez le répertoire dans lequel Fluent enregistre les fichiers pour votre projet. Le nom des fichiers de cas a souvent un format tel que FFF-1.cas.gz.
  3. Si vous voulez poursuivre avec des données d'un calcul effectué précédemment, exportez aussi un fichier de données avec File > Export > Data… ou trouvez-le dans le même répertoire de projet (FFF-1.dat.gz).
  4. Transférez le fichier de cas (et le fichier de données s'il y a lieu) dans le système de fichiers /project ou /scratch de la grappe. Quand les fichiers sont exportés, sauvegardez-les avec des noms plus faciles à repérer que FFF-1.* ou renommez-les au téléversement.
  5. Créez un fichier de journalisation dont le but est de charger les fichiers de cas (et le fichier de données s'il y a lieu), lancez le solveur et enregistrez les résultats. Voyez les exemples ci-dessous et n'oubliez pas d'ajuster les noms des fichiers et le nombre d'itérations.
  6. S'il arrive fréquemment que les tâches ne démarrent pas en raison d'un manque de licence (et que de les soumettre de nouveau manuellement ne convient pas), vous pouvez modifier votre script pour que votre tâche soit remise en file d'attente (au plus 4 fois) comme c'est le cas pour le script sous l'onglet Plusieurs nœuds (par cœur + remise en attente) plus loin. Cependant, ceci remet aussi en attente les simulations qui ont échoué pour d'autres raisons que l'absence de licence (par exemple la divergence) gaspillant ainsi du temps de calcul. Il est donc fortement recommandé de vérifier les fichiers de sortie de l'ordonnanceur pour savoir si chaque tentative de remise en attente est ou non due à un problème de licence. Si vous découvrez que la remise en attente est due à un problème avec la simulation, annulez immédiatement la tâche avec scancel jobid et corrigez le problème.
  7. Lorsque la tâche est terminée, vous pouvez télécharger le fichier de données et le retourner dans Fluent avec File > Import > Data….

Scripts pour l'ordonnanceur Slurm

Utilisation générale

La plupart des tâches Fluent devraient utiliser le script par nœud ci-dessous pour minimiser le temps d'attente et maximiser la performance en utilisant le moins de nœuds possible. Les tâches demandant beaucoup de cœurs CPU pourraient attendre moins longtemps dans la queue avec le script par cœur, mais le démarrage d’une tâche utilisant plusieurs nœuds peut prendre beaucoup plus de temps, ce qui en diminue l'intérêt. Il faut aussi tenir compte du fait qu'exécuter des tâches intensives sur un nombre indéterminé de nœuds pouvant être très élevé fait en sorte que ces tâches seront beaucoup plus susceptibles de planter si un des nœuds de calcul fait défaut pendant la simulation. Les scripts suivants utilisent la mémoire partagée pour les tâches utilisant un seul nœud et la mémoire distribuée (avec MPI et l’interconnexion CHP appropriée) pour les tâches en utilisant plusieurs.

File : script-flu-bynode.sh

#!/bin/bash

#SBATCH --account=def-group   # indiquer le nom du compte
#SBATCH --time=00-03:00       # indiquer la limite de temps (jj-hh:mm)
#SBATCH --nodes=1             # indiquer le nombre de nœuds de calcul (1 ou plus)
#SBATCH --ntasks-per-node=32  # indiquer le nombre de cœurs par nœud (graham 32 ou 44, cedar 48, beluga 40, narval 64)
#SBATCH --mem=0               # ne pas modifier; ceci alloue toute la mémoire du nœud de calcul
#SBATCH --cpus-per-task=1     # ne pas modifier

rm -f cleanup* core*

#module load StdEnv/2016      # s’applique à Cedar, Béluga, Graham
#module load ansys/2020R2     # ou versions précédentes

#module load StdEnv/2020      # s’applique uniquement à Narval
#module load ansys/2019R3     # ou versions suivantes

module load StdEnv/2020       # s’applique à Cedar, Béluga, Graham
module load ansys/2021R2      # ou versions suivantes

<div class="mw-translate-fuzzy">
if [[ "${CC_CLUSTER}" == narval && "${EBVERSIONANSYS}" == @(2019R3|2020R2) ]]; then
 module load intel/2021 intelmpi
 export INTELMPI_ROOT=$I_MPI_ROOT/mpi/latest
 unset I_MPI_HYDRA_BOOTSTRAP_EXEC_EXTRA_ARGS
 unset I_MPI_ROOT
fi
</div>

slurm_hl2hl.py --format ANSYS-FLUENT > /tmp/machinefile-$SLURM_JOB_ID
NCORES=$((SLURM_NTASKS * SLURM_CPUS_PER_TASK))

<div class="mw-translate-fuzzy">
# indiquer 2d, 2ddp, 3d ou 3ddp et remplacer le nom de fichier sample par le nom de votre fichier de journalisation
if [ "$SLURM_NNODES" == 1 ]; then
 fluent -g 2ddp -t $NCORES -affinity=0 -i sample.jou
else 
 fluent -g 2ddp -t $NCORES -affinity=0 -cnf=/tmp/machinefile-$SLURM_JOB_ID -mpi=intel -ssh -i sample.jou 
fi


File : script-flu-bycore.sh

#!/bin/bash

#SBATCH --account=def-group   # indiquer le nom du compte
#SBATCH --time=00-03:00       # indiquer la limite de temps (jj-hh:mm)
##SBATCH --nodes=2            # optionnel; supprimer ce commentaire pour indiquer 1 ou plusieurs nœuds de calcul
#SBATCH --ntasks=16           # indiquer le nombre total de cœurs
#SBATCH --mem-per-cpu=4G      # indiquer la quantité de mémoire par coeur
#SBATCH --cpus-per-task=1     # ne pas modifier

rm -f cleanup* core*

#module load StdEnv/2016      # s’applique à Cedar, Béluga, Graham
#module load ansys/2020R2     # ou versions précédentes

#module load StdEnv/2020      # s’applique uniquement à Narval
#module load ansys/2019R3     # ou versions suivantes

module load StdEnv/2020       # s’applique à Cedar, Béluga, Graham
module load ansys/2021R2      # ou versions suivantes

<div class="mw-translate-fuzzy">
if [[ "${CC_CLUSTER}" == narval && "${EBVERSIONANSYS}" == @(2019R3|2020R2) ]]; then
 module load intel/2021 intelmpi
 export INTELMPI_ROOT=$I_MPI_ROOT/mpi/latest
 unset I_MPI_HYDRA_BOOTSTRAP_EXEC_EXTRA_ARGS
 unset I_MPI_ROOT
fi
</div>

slurm_hl2hl.py --format ANSYS-FLUENT > /tmp/machinefile-$SLURM_JOB_ID
NCORES=$((SLURM_NTASKS * SLURM_CPUS_PER_TASK))

<div class="mw-translate-fuzzy">
# indiquer 2d, 2ddp, 3d ou 3ddp et remplacer le nom de fichier sample par le nom de votre fichier de journalisation
if [ "$SLURM_NNODES" == 1 ]; then
 fluent -g 2ddp -t $NCORES -affinity=0 -i sample.jou
else 
 fluent -g 2ddp -t $NCORES -affinity=0 -cnf=/tmp/machinefile-$SLURM_JOB_ID -mpi=intel -ssh -i sample.jou 
fi


Remise en file d'attente pour obtenir la licence

Ces scripts peuvent être utilisés pour remettre automatiquement en file d'attente les tâches Fluent qui se terminent anormalement dès qu'elles sont lancées et qui nécessitent plusieurs essais pour obtenir les licences requises d'un serveur distant. Ceci peut se produire quand le serveur de licence est très sollicité, que le réseau est momentanément instable ou qu'il n'y a plus de licences. Il n'est pas recommandé d'utiliser ces scripts avec des tâches Fluent qui commencent normalement et qui prennent beaucoup de temps avant de planter (par exemple en raison d'un problème avec un nœud, de divergence ou d'arrêt par manque de temps de l'ordonnanceur) puisqu'elles seront reprises depuis le début plutôt que d'utiliser le plus récent fichier de données, ce qui résulte en une perte importante de temps et de ressources de calcul.

File : script-flu-bynode+requeue.sh

#!/bin/bash

#SBATCH --account=def-group   # indiquer le nom du compte
#SBATCH --time=00-03:00       # indiquer la limite de temps (jj-hh:mm)
#SBATCH --nodes=1             # indiquer le nombre de nœuds de calcul (1 ou plus)
#SBATCH --ntasks-per-node=32  # indiquer le nombre de cœurs par nœud (graham 32 ou 44, cedar 48, beluga 40, narval 64)
#SBATCH --mem=0               # ne pas modifier; ceci alloue toute la mémoire du nœud de calcul
#SBATCH --cpus-per-task=1     # ne pas modifier
#SBATCH --array=1-5%1         # indiquer le nombre de tentatives de remise en attente (2 ou plus); ici, le nombre demandé est 5

rm -f cleanup* core*

#module load StdEnv/2016      # s’applique à Cedar, Béluga, Graham
#module load ansys/2020R2     # ou versions précédentes

#module load StdEnv/2020      # s’applique uniquement à Narval
#module load ansys/2019R3     # ou versions suivantes

module load StdEnv/2020       # s’applique à Cedar, Béluga, Graham
module load ansys/2021R2      # ou versions suivantes

<div class="mw-translate-fuzzy">
if [[ "${CC_CLUSTER}" == narval && "${EBVERSIONANSYS}" == @(2019R3|2020R2) ]]; then
 module load intel/2021 intelmpi
 export INTELMPI_ROOT=$I_MPI_ROOT/mpi/latest
 unset I_MPI_HYDRA_BOOTSTRAP_EXEC_EXTRA_ARGS
 unset I_MPI_ROOT
fi
</div>

slurm_hl2hl.py --format ANSYS-FLUENT > /tmp/machinefile-$SLURM_JOB_ID
NCORES=$((SLURM_NTASKS * SLURM_CPUS_PER_TASK))

# indiquer 2d, 2ddp, 3d ou 3ddp et remplacer le nom de fichier sample par le nom de votre fichier de journalisation
if [ "$SLURM_NNODES" == 1 ]; then
 fluent -g 2ddp -t $NCORES -affinity=0 -i sample.jou
else 
 fluent -g 2ddp -t $NCORES -affinity=0 -cnf=/tmp/machinefile-$SLURM_JOB_ID -mpi=intel -ssh -i sample.jou 
fi
if [ $? -eq 0 ]; then
    echo "Job completed successfully! Exiting now."
    scancel $SLURM_ARRAY_JOB_ID
else
    echo "Job attempt $SLURM_ARRAY_TASK_ID of $SLURM_ARRAY_TASK_COUNT failed due to license or simulation issue!"
    if [ $SLURM_ARRAY_TASK_ID -lt $SLURM_ARRAY_TASK_COUNT ]; then
       echo "Resubmitting job now …"
    else
       echo "All job attempts failed exiting now."
    fi
fi


File : script-flu-bycore+requeue.sh

#!/bin/bash

#SBATCH --account=def-group   # indiquer le nom du compte
#SBATCH --time=00-03:00       # indiquer la limite de temps (jj-hh:mm)
##SBATCH --nodes=2            # optionnel; supprimer ce commentaire pour indiquer 1 ou plusieurs nœuds de calcul
#SBATCH --ntasks=16           # indiquer le nombre total de cœurs
#SBATCH --mem-per-cpu=4G      # indiquer la quantité de mémoire par coeur
#SBATCH --cpus-per-task=1     # ne pas modifier
#SBATCH --array=1-5%1         # indiquer le nombre de tentatives de remise en attente (2 ou plus); ici, le nombre demandé est 5

rm -f cleanup* core*

#module load StdEnv/2016      # s’applique à Cedar, Béluga, Graham
#module load ansys/2020R2     # ou versions précédentes

#module load StdEnv/2020      # s’applique uniquement à Narval
#module load ansys/2019R3     # ou versions suivantes

module load StdEnv/2020       # s’applique à Cedar, Béluga, Graham
module load ansys/2021R2      # ou versions suivantes

<div class="mw-translate-fuzzy">
if [[ "${CC_CLUSTER}" == narval && "${EBVERSIONANSYS}" == @(2019R3|2020R2) ]]; then
 module load intel/2021 intelmpi
 export INTELMPI_ROOT=$I_MPI_ROOT/mpi/latest
 unset I_MPI_HYDRA_BOOTSTRAP_EXEC_EXTRA_ARGS
 unset I_MPI_ROOT
fi
</div>

slurm_hl2hl.py --format ANSYS-FLUENT > /tmp/machinefile-$SLURM_JOB_ID
NCORES=$((SLURM_NTASKS * SLURM_CPUS_PER_TASK))

# indiquer 2d, 2ddp, 3d ou 3ddp et remplacer le nom de fichier sample par le nom de votre fichier de journalisation
if [ "$SLURM_NNODES" == 1 ]; then
 fluent -g 2ddp -t $NCORES -affinity=0 -i sample.jou
else 
 fluent -g 2ddp -t $NCORES -affinity=0 -cnf=/tmp/machinefile-$SLURM_JOB_ID -mpi=intel -ssh -i sample.jou 
fi
if [ $? -eq 0 ]; then
    echo "Job completed successfully! Exiting now."
    scancel $SLURM_ARRAY_JOB_ID
else
    echo "Job attempt $SLURM_ARRAY_TASK_ID of $SLURM_ARRAY_TASK_COUNT failed due to license or simulation issue!"
    if [ $SLURM_ARRAY_TASK_ID -lt $SLURM_ARRAY_TASK_COUNT ]; then
       echo "Resubmitting job now …"
    else
       echo "All job attempts failed exiting now."
    fi
fi


Redémarrage

Les deux scripts suivants automatisent le redémarrage de tâches intensives qui exigent plus que le maximum de sept jours d'exécution permis sur la plupart des grappes. Le redémarrage se fait à partir des fichiers de valeur de pas de temps les plus récemment sauvegardés. Une exigence de base est que le premier pas puisse être terminé avant la fin du temps demandé dans le vecteur de tâches (défini dans le haut du script) quand une simulation est lancée à partir d'un champ initialisé. Nous supposons que la valeur du pas est fixe. Pour commencer un groupe de sample.cas, il faut que les fichiers sample.dat et sample.jou soient présents. Modifiez le fichier sample.jou pour qu'il contienne /solve/dual-time-iterate 1 et /file/auto-save/data-frequency 1. Créez ensuite un fichier de journalisation avec cp sample.jou sample-restart.jou et modifiez le fichier sample-restart.jou pour qu'il contienne /file/read-cas-data sample-restart plutôt que /file/read-cas-data sample et mettez en commentaire la ligne pour l'initialisation en la précédant d’un point-virgule, par exemple ;/solve/initialize/initialize-flow. Si votre deuxième pas et les pas qui suivent sont exécutés deux fois plus vite que le pas initial, modifiez sample-restart.jou en spécifiant /solve/dual-time-iterate 2. De cette façon, la solution ne sera redémarrée qu'après que les deux pas suivant le pas initial soient terminés. Un fichier de résultats pour chaque pas sera enregistré dans le répertoire de sortie. La valeur 2 est arbitraire, mais elle devrait être utilisée pour que la durée de deux pas soit moindre que la durée allouée au vecteur de tâches. Ceci limitera le nombre de redémarrages, qui consomment beaucoup de ressources. Si le premier pas de sample.jou est fait à partir d'une solution précédente, choisissez 1 plutôt que 2 puisque tous les pas auront probablement besoin du même temps d'exécution. En supposant que 2 est choisi, la durée totale de la simulation sera 1*Dt+2*Nrestart*Dt où Nrestart est le nombre de redémarrages défini dans le script Slurm. Le nombre total de pas (de même que le nombre de fichiers de résultats générés) sera ainsi 1+2*Nrestart. La valeur pour le temps demandé devrait être choisie afin que le pas initial et les pas suivants se terminent dans la fenêtre de temps de Slurm, qui peut aller jusqu'à #SBATCH --time=07-00:00 jours.

File : script-flu-bynode+restart.sh

#!/bin/bash

#SBATCH --account=def-group   # indiquer le nom du compte
#SBATCH --time=00-03:00       # indiquer la limite de temps (jj-hh:mm)
#SBATCH --nodes=1             # indiquer le nombre de nœuds de calcul (1 ou plus)
#SBATCH --ntasks-per-node=32  # indiquer le nombre de cœurs par nœud (graham 32 ou 44, cedar 48, beluga 40, narval 64)
#SBATCH --mem=0               # ne pas modifier; ceci alloue toute la mémoire du nœud de calcul
#SBATCH --cpus-per-task=1     # ne pas modifier
#SBATCH --array=1-5%1         # indiquer le nombre de tentatives de remise en attente (2 ou plus); ici, le nombre demandé est 5

rm -f cleanup* core*

#module load StdEnv/2016      # s’applique à Cedar, Béluga, Graham
#module load ansys/2020R2     # ou versions précédentes

#module load StdEnv/2020      # s’applique uniquement à Narval
#module load ansys/2019R3     # ou versions suivantes

module load StdEnv/2020       # s’applique à Cedar, Béluga, Graham
module load ansys/2021R2      # ou versions suivantes

<div class="mw-translate-fuzzy">
if [[ "${CC_CLUSTER}" == narval && "${EBVERSIONANSYS}" == @(2019R3|2020R2) ]]; then
 module load intel/2021 intelmpi
 export INTELMPI_ROOT=$I_MPI_ROOT/mpi/latest
 unset I_MPI_HYDRA_BOOTSTRAP_EXEC_EXTRA_ARGS
 unset I_MPI_ROOT
fi
</div>

slurm_hl2hl.py --format ANSYS-FLUENT > /tmp/machinefile-$SLURM_JOB_ID
NCORES=$((SLURM_NTASKS * SLURM_CPUS_PER_TASK))

# indiquer 2d, 2ddp, 3d ou 3ddp et remplacer le nom de fichier sample par le nom de votre fichier de journalisation
if [ "$SLURM_NNODES" == 1 ]; then
  if [ "$SLURM_ARRAY_TASK_ID" == 1 ]; then
    fluent -g 2ddp -t $NCORES -affinity=0 -i sample.jou
  else
    fluent -g 2ddp -t $NCORES -affinity=0 -i sample-restart.jou
  fi
else 
  if [ "$SLURM_ARRAY_TASK_ID" == 1 ]; then
    fluent -g 2ddp -t $NCORES -affinity=0 -cnf=/tmp/machinefile-$SLURM_JOB_ID -mpi=intel -ssh -i sample.jou 
  else
    fluent -g 2ddp -t $NCORES -affinity=0 -cnf=/tmp/machinefile-$SLURM_JOB_ID -mpi=intel -ssh -i sample-restart.jou 
  fi
fi
if [ $? -eq 0 ]; then
    echo
    echo "SLURM_ARRAY_TASK_ID  = $SLURM_ARRAY_TASK_ID"
    echo "SLURM_ARRAY_TASK_COUNT = $SLURM_ARRAY_TASK_COUNT"
    echo
    if [ $SLURM_ARRAY_TASK_ID -lt $SLURM_ARRAY_TASK_COUNT ]; then
      echo "Restarting job with the most recent output dat file …"
      ln -sfv output/$(ls -ltr output | grep .cas | tail -n1 | awk '{print $9}') sample-restart.cas.gz
      ln -sfv output/$(ls -ltr output | grep .dat | tail -n1 | awk '{print $9}') sample-restart.dat.gz
      ls -lh cavity* output/*
    else
      echo "Job completed successfully! Exiting now."
      scancel $SLURM_ARRAY_JOB_ID
     fi
else
     echo "Simulation failed. Exiting …"
fi


File : script-flu-bycore+restart.sh

#!/bin/bash

#SBATCH --account=def-group   # indiquer le nom du compte
#SBATCH --time=00-03:00       # indiquer la limite de temps (jj-hh:mm)
##SBATCH --nodes=2            # optionnel; supprimez ce commentaire pour indiquer 1 ou plusieurs nœuds de calcul
#SBATCH --ntasks=16           # indiquer le nombre total de cœurs
#SBATCH --mem-per-cpu=4G      # indiquer la quantité de mémoire par coeur
#SBATCH --cpus-per-task=1     # ne pas modifier
#SBATCH --array=1-5%1         # indiquer le nombre de tentatives de remise en attente (2 ou plus); ici, le nombre demandé est 5

rm -f cleanup* core*

#module load StdEnv/2016      # s’applique à Cedar, Béluga, Graham
#module load ansys/2020R2     # ou versions précédentes

#module load StdEnv/2020      # s’applique uniquement à Narval
#module load ansys/2019R3     # ou versions suivantes

module load StdEnv/2020       # s’applique à Cedar, Béluga, Graham
module load ansys/2021R2      # ou versions suivantes

<div class="mw-translate-fuzzy">
if [[ "${CC_CLUSTER}" == narval && "${EBVERSIONANSYS}" == @(2019R3|2020R2) ]]; then
 module load intel/2021 intelmpi
 export INTELMPI_ROOT=$I_MPI_ROOT/mpi/latest
 unset I_MPI_HYDRA_BOOTSTRAP_EXEC_EXTRA_ARGS
 unset I_MPI_ROOT
fi
</div>

slurm_hl2hl.py --format ANSYS-FLUENT > /tmp/machinefile-$SLURM_JOB_ID
NCORES=$((SLURM_NTASKS * SLURM_CPUS_PER_TASK))

# indiquer 2d, 2ddp, 3d ou 3ddp et remplacer le nom de fichier sample par le nom de votre fichier de journalisation
if [ "$SLURM_NNODES" == 1 ]; then
  if [ "$SLURM_ARRAY_TASK_ID" == 1 ]; then
    fluent -g 2ddp -t $NCORES -affinity=0 -i sample.jou
  else
    fluent -g 2ddp -t $NCORES -affinity=0 -i sample-restart.jou
  fi
else 
  if [ "$SLURM_ARRAY_TASK_ID" == 1 ]; then
    fluent -g 2ddp -t $NCORES -affinity=0 -cnf=/tmp/machinefile-$SLURM_JOB_ID -mpi=intel -ssh -i sample.jou 
  else
    fluent -g 2ddp -t $NCORES -affinity=0 -cnf=/tmp/machinefile-$SLURM_JOB_ID -mpi=intel -ssh -i sample-restart.jou 
  fi
fi
if [ $? -eq 0 ]; then
    echo
    echo "SLURM_ARRAY_TASK_ID  = $SLURM_ARRAY_TASK_ID"
    echo "SLURM_ARRAY_TASK_COUNT = $SLURM_ARRAY_TASK_COUNT"
    echo
    if [ $SLURM_ARRAY_TASK_ID -lt $SLURM_ARRAY_TASK_COUNT ]; then
      echo "Restarting job with the most recent output dat file …"
      ln -sfv output/$(ls -ltr output | grep .cas | tail -n1 | awk '{print $9}') sample-restart.cas.gz
      ln -sfv output/$(ls -ltr output | grep .dat | tail -n1 | awk '{print $9}') sample-restart.dat.gz
      ls -lh cavity* output/*
    else
      echo "Job completed successfully! Exiting now."
      scancel $SLURM_ARRAY_JOB_ID
     fi
else
     echo "Simulation failed. Exiting …"
fi


Fichiers de journalisation

Les fichiers de journalisation peuvent contenir toutes les commandes de l'interface TUI (Text User Interface) de Fluent; elles peuvent être utilisées pour modifier des paramètres de simulation comme la température, la pression ou la vitesse du flux. Vous pouvez ainsi effectuer une série de simulations sous différentes conditions simplement en modifiant les paramètres du fichier de journalisation. Consultez le guide d'utilisation de Fluent pour plus d'information ainsi que pour connaître la liste des commandes. Les fichiers qui suivent sont configurés avec /file/cff-file no pour utiliser les formats de fichiers .cas/.dat qui sont les formats par défaut pour les modules jusqu'à 2019R3. Pour utiliser les formats .cas.h5/.dat.h5 plus efficaces des versions à partir de 2020R1, la configuration est /file/cff-files yes.

File : sample1.jou

; EXEMPLE DE FICHIER DE JOURNALISATION - SIMULATION STABLE
; ----------------------------------------------
; le point-virgule en début de ligne signale un commentaire

; lire/écrire des fichiers CFF (common fluids format) [yes par défaut]
/file/cff-files no

; lire les fichiers en entrée pour les cas et les données
/file/read-case-data FFF-in

; itérations du solveur
/solve/iterate 1000

; écraser par défaut les fichiers de sortie
/file/confirm-overwrite n

; écrire le dernier fichier de données en sortie
/file/write-data FFF-out

; enregistrer le rapport de la simulation (optionnel)
/report/summary y "My_Simulation_Report.txt"

; sortir de Fluent (nécessaire pour la remise en file d’attente)
exit


File : sample2.jou

; EXEMPLE DE FICHIER DE JOURNALISATION - SIMULATION STABLE
; ----------------------------------------------
; le point-virgule en début de ligne signale un commentaire

; lire/écrire des fichiers CFF (common fluids format) [yes, par défaut]
/file/cff-files no

; lire les fichiers en entrée (.cas/.dat ou .cas.h5/.dat.h5)
/file/read-case-data FFF-in

; enregistrer un fichier de données après chaque 100 itérations
/file/auto-save/data-frequency 100

; conserver les données des 5 dernières itérations
/file/auto-save/retain-most-recent-files y

; enregistrer les fichiers de données dans les sous-répertoire des données en sortie (ajouter à la fin de chaque itération)
/file/auto-save/root-name output/FFF-out

; exécuter le solveur ce nombre d’itérations
/solve/iterate 1000

; écrire le dernier fichier de cas et de données en sortie
/file/write-case-data FFF-out

; enregistrer le rapport de la simulation (optionnel)
/report/summary y "My_Simulation_Report.txt"

; sortir de Fluent (nécessaire pour la remise en file d’attente)
exit


File : sample3.jou

; EXEMPLE DE FICHIER DE JOURNALISATION - SIMULATION TEMPORAIRE
; ----------------------------------------------
; le point-virgule en début de ligne signale un commentaire

; lire/écrire des fichiers CFF (common fluids format) [yes par défaut]
/file/cff-files no

; lire uniquement le fichier de cas en entrée
/file/read-case FFF-transient-inp

; pour continuer (redémarrage) lire dans les fichiers de cas et les fichiers de données en entrée
;/file/read-case-data FFF-transient-inp

; enregistrer le fichier de données (et peut-être de cas) à chaque 100 pas
/file/auto-save/data-frequency 100
/file/auto-save/case-frequency if-case-is-modified

; conserver uniquement les 5 plus récents fichiers de données (et peut-être de cas)
/file/auto-save/retain-most-recent-files y

; enregistrer dans le sous-répertoire de sortie; ajoute la durée du flux (''flowtime'') et le pas
/file/auto-save/root-name output/FFF-transient-out-%10.6f

; ##### Paramètres  #####

; indiquer la valeur physique du pas
/solve/set/time-step 0.0001

; indiquer le nombre maximal d'itérations par pas
/solve/set/max-iterations-per-time-step 20

; indiquer le nombre d'itérations après lesquelles la convergence est rapportée 
/solve/set/reporting-interval 1

; ##### Fin des paramètres #####

; initialiser avec la méthode hybride
/solve/initialize/hyb-initialization

; effectuer les itérations instables pour un nombre défini de pas
/solve/dual-time-iterate 1000 ,

; enregistrer les derniers fichiers en sortie pour les cas et les données
/file/write-case-data FFF-transient-out

; enregistrer le rapport de la simulation (optionnel)
/report/summary y Report_Transient_Simulation.txt

; sortir de Fluent (nécessaire pour la remise en file d’attente)
exit


Ansys CFX

Scripts pour l'ordonnanceur Slurm

File : script-cfx.sh

#!/bin/bash

#SBATCH --account=def-group   # indiquer le nom du compte
#SBATCH --time=00-03:00       # indiquer la limite de temps (jj-hh:mm)
#SBATCH --nodes=1             # indiquer le nombre de nœuds de calcul (1 ou plus)
#SBATCH --cpus-per-task=32    # indiquer le nombre de cœurs par nœud (Graham 32 ou 44, Cedar 32 ou 48, Béluga 40)
#SBATCH --mem=0               # ne pas modifier; ceci alloue toute la mémoire du nœud de calcul
#SBATCH --ntasks-per-node=1   # ne pas modifier

#module load StdEnv/2016      # s’applique à Cedar, Béluga, Graham
#module load ansys/2020R2     # ou versions précédentes

module load StdEnv/2020       # s’applique à Graham, Cedar, Béluga, Graham

module load ansys/2021R1      # ou versions suivantes

NNODES=$(slurm_hl2hl.py --format ANSYS-CFX)

# au besoin, ajouter des options à la ligne de commande
cfx5solve -def YOURFILE.def -start-method "Intel MPI Distributed Parallel" -par-dist $NNODES
File : script-cfx.sh

#!/bin/bash

#SBATCH --account=def-group   # indiquer le nom du compte
#SBATCH --time=00-03:00       # indiquer la limite de temps (jj-hh:mm)
#SBATCH --ntasks-per-node=4   # indiquer le nombre de cœurs (jusqu'à 64 pour Narval)
#SBATCH --mem=8G              # indiquer 0 quand vous utilisez tous les cœurs 
#SBATCH --nodes=1             # ne pas modifier

module load StdEnv/2020       # s'applique à Narval, Graham, Cedar
module load ansys/2020R2      # ou à la version 2019R3

# au besoin, ajouter des options à la ligne de commande
cfx5solve -def YOURFILE.def -start-method "Open MPI Local Parallel" -part $SLURM_CPUS_ON_NODE

Remarque : Il est possible que vous receviez un message comme /etc/tmi.conf: No such file or directory; ces messages n'ont toutefois pas d'effet sur les calculs.

Workbench

Avant de soumettre une tâche (sbatch script-wbpj.sh) pour la queue : 1. définissez le nom du fichier YOURPROJECT.wbpj dans un des scripts ci-dessous; 2. initialisez le projet en l'ouvrant dans Ansys Workbench tel que décrit dans la section Mode graphique. Cliquez sur File -> Open pour charger le projet, démarrez Mechanical en faisant un double-clic sur Setup ou Solution pour le système d'analyse dans la fenêtre principale. Cliquez sur File -> Clear Generated Data -> Yes, cliquez sur File -> Save Project, cliquez sur File -> Close Mechanical et cliquez sur File -> Exit.

Pour ne pas écrire la solution quand une tâche se termine avec succès sur une grappe, enlevez ;Save(Overwrite=True) de la dernière ligne du script Slurm. Il sera ainsi plus facile d'effectuer plusieurs tâches de test (pour une mise à l'échelle quand vous changez ntasks) puisque la solution initialisée ne sera pas écrasée à chaque fois et donc n'aura pas besoin d'être réinitialisée entre les tâches. Ou encore, vous pouvez sauvegarder une copie du fichier initialisé YOURPROJECT.wbpj et du sous-répertoire YOURPROJECT_files avant que chaque tâche soit soumise et les restaurer ensuite une fois que la solution est écrite. Pour des simulations APDL dans l'ancien environnement StdEnv/2016, vous pouvez soit retirer nodes=1 du script ou lui attribuer une valeur de plus de 1 pour que les calculs soient effectués sur plusieurs nœuds.

Scripts pour l'ordonnanceur Slurm

File : script-wbpj-2020.sh

#!/bin/bash

#SBATCH --account=def-account
#SBATCH --time=00-03:00                # indiquer la limite de temps (jj-hh:mm)
#SBATCH --mem=16G                      # indiquer la mémoire totale (valeur de 0 pour allouer toute la mémoire du nœud)
#SBATCH --ntasks=4                     # indiquer le nombre de cœurs
#SBATCH --nodes=1                      # ne pas modifier
##SBATCH --exclusif                    # supprimer ce commentaire pour les tests de scalabilité
##SBATCH --constraint=broadwell        # s'applique à Graham, Cedar

module load StdEnv/2020 ansys/2021R2   # ou modules suivants (la mémoire parallèle distribuée n'est pas supportée sur Narval avec 2021R2)

MEMPAR=0                               # indiquer 0 pour la mémoire parallèle partagée ou 1 pour la mémoire parallèle distribuée

rm -fv *_files/.lock
MWFILE=~/.mw/Application\ Data/Ansys/`basename $(find $EBROOTANSYS/v* -maxdepth 0 -type d)`/SolveHandlers.xml
sed -re "s/(.AnsysSolution>+)[a-zA-Z0-9]*(<\/Distribute.)/\1$MEMPAR\2/" -i "$MWFILE"
sed -re "s/(.Processors>+)[a-zA-Z0-9]*(<\/MaxNumber.)/\1$SLURM_NTASKS\2/" -i "$MWFILE"
sed -i "s!UserConfigured=\"0\"!UserConfigured=\"1\"!g" "$MWFILE"

export KMP_AFFINITY=disabled
export I_MPI_HYDRA_BOOTSTRAP=ssh

runwb2 -B -E "Update();Save(Overwrite=True)" -F YOURPROJECT.wbpj


File : script-wbpj-2016.sh

#!/bin/bash

#SBATCH --account=def-account
#SBATCH --time=00-03:00                # indiquer la limite de temps (jj-hh:mm)
#SBATCH --mem=16G                      # indiquer la mémoire totale (valeur de 0 pour allouer toute la mémoire du nœud)
#SBATCH --ntasks=4                     # indiquer le nombre de cœurs
#SBATCH --nodes=1                      # ne pas modifier

module load StdEnv/2016 ansys/2019R3   # ne pas modifier

MEMPAR=1                               # ne pas modifier

rm -fv *_files/.lock
MWFILE=~/.mw/Application\ Data/Ansys/`basename $(find $EBROOTANSYS/v* -maxdepth 0 -type d)`/SolveHandlers.xml
sed -re "s/(.AnsysSolution>+)[a-zA-Z0-9]*(<\/Distribute.)/\1$MEMPAR\2/" -i "$MWFILE"
sed -re "s/(.Processors>+)[a-zA-Z0-9]*(<\/MaxNumber.)/\1$((SLURM_NTASKS-1))\2/" -i "$MWFILE"

export KMP_AFFINITY=balanced
export I_MPI_HYDRA_BOOTSTRAP=ssh
export PATH=/cvmfs/soft.computecanada.ca/nix/var/nix/profiles/16.09/bin:$PATH

runwb2 -B -E "Update();Save(Overwrite=True)" -F YOURPROJECT.wbpj


Mechanical

Le fichier d'entrée peut être généré dans votre session interactive Workbench Mechanical en cliquant sur Solution -> Tools -> Write Input Files et en spécifiant File name: pour YOURAPDLFILE.inp et Save as type: pour les fichiers APDL en entrée (*.inp). Les tâches APDL peuvent ensuite être soumises à la queue avec la commande sbatch script-name.sh.

Scripts pour l'ordonnanceur Slurm

Les modules Ansys dans les scripts suivants ont été testés sur Graham et devraient fonctionner sans problème (supprimez les marques de commentaire). S'il y a lieu, ils seront mis à jour une fois qu'ils auront été testés sur d'autres grappes.

File : script-smp-2016.sh

#!/bin/bash
#SBATCH --account=def-account  # indiquer le nom du compte
#SBATCH --time=00-03:00        # indiquer la limite de temps (jj-hh:mm)
#SBATCH --mem=16G              # indiquer la quantité de mémoire par coeur
#SBATCH --ntasks=8             # indiquer le nombre de cœurs (1 ou plus)
#SBATCH --nodes=1              # spécifier un nœud (ne pas modifier)

unset SLURM_GTIDS

module load StdEnv/2016

#module load ansys/19.1
#module load ansys/19.2
#module load ansys/2019R2
#module load ansys/2019R3
#module load ansys/2020R1
module load ansys/2020R2

mapdl -smp -b nolist -np $SLURM_NTASKS -dir $SLURM_TMPDIR -I YOURAPDLFILE.inp

rm -rf results-*
mkdir results-$SLURM_JOB_ID
cp -a --no-preserve=ownership $SLURM_TMPDIR/* results-$SLURM_JOB_ID


File : script-smp-2020.sh

#!/bin/bash
#SBATCH --account=def-account  # indiquer le nom du compte
#SBATCH --time=00-03:00        # indiquer la limite de temps (jj-hh:mm)
#SBATCH --mem=16G              # indiquer la mémoire pour tous les cœurs 
#SBATCH --ntasks=8             # indiquer le nombre de cœurs (1 ou plus)
#SBATCH --nodes=1              # spécifier un nœud (ne pas modifier)

unset SLURM_GTIDS

module load StdEnv/2020

#module load ansys/2021R2
#module load ansys/2022R1
module load ansys/2022R2

mapdl -smp -b nolist -np $SLURM_NTASKS -dir $SLURM_TMPDIR -I YOURAPDLFILE.inp

rm -rf results-*
mkdir results-$SLURM_JOB_ID
cp -a --no-preserve=ownership $SLURM_TMPDIR/* results-$SLURM_JOB_ID


File : script-dis-2016.sh

#!/bin/bash
#SBATCH --account=def-account  # indiquer le nom du compte
#SBATCH --time=00-03:00        # indiquer la limite de temps (jj-hh:mm)
#SBATCH --mem-per-cpu=2G       # indiquer la quantité de mémoire par coeur
#SBATCH --ntasks=8             # indiquer le nombre de cœurs (2 ou plus)
##SBATCH --nodes=2             # indiquer le nombre de nœuds (optionnel)
##SBATCH --ntasks-per-node=4   # indiquer le nombre de cœurs par nœuds (optionnel)

unset SLURM_GTIDS

module load StdEnv/2016

#module load ansys/2019R3
module load ansys/2020R1

export I_MPI_HYDRA_BOOTSTRAP=ssh; export KMP_AFFINITY=compact
mapdl -dis -mpi intelmpi -b nolist -np $SLURM_NTASKS -dir $SLURM_TMPDIR -I YOURAPDLFILE.inp

rm -rf results-*
mkdir results-$SLURM_JOB_ID
cp -a --no-preserve=ownership $SLURM_TMPDIR/* results-$SLURM_JOB_ID


File : script-dis-2020.sh

#!/bin/bash
#SBATCH --account=def-account  # indiquer le nom du compte
#SBATCH --time=00-03:00        # indiquer la limite de temps (jj-hh:mm)
#SBATCH --mem-per-cpu=2G       # indiquer la quantité de mémoire par coeur
#SBATCH --ntasks=8             # indiquer le nombre de cœurs (2 ou plus)
##SBATCH --nodes=2             # indiquer le nombre de nœuds (optionnel)
##SBATCH --ntasks-per-node=4   # indiquer le nombre de cœurs par nœuds (optionnel)

unset SLURM_GTIDS

module load StdEnv/2020

module load ansys/2022R2

mapdl -dis -mpi openmpi -b nolist -np $SLURM_NTASKS -dir $SLURM_TMPDIR -I YOURAPDLFILE.inp

rm -rf results-*
mkdir results-$SLURM_JOB_ID
cp -a --no-preserve=ownership $SLURM_TMPDIR/* results-$SLURM_JOB_ID


Par défaut, Ansys alloue aux tâches APDL 1024Mo de mémoire totale et 1024Mo de mémoire pour les bases de données. Ces valeurs peuvent être définies manuellement (ou modifiées) avec l'ajout des arguments -m 1024 et/ou -db 1024 sur la dernière ligne de commande mapdl des scripts ci-dessus. Si vous utilisez à distance un serveur de licences de votre établissement qui a plusieurs licences Ansys, il pourrait être nécessaire d'ajouter des arguments comme -p aa_r ou -ppf anshpc, selon le module que vous utilisez. Comme d'habitude, effectuez des tests détaillés de mise à l'échelle avant de lancer des tâches en production pour vous assurer que vous utilisez le nombre optimal de cœurs et la bonne quantité minimale de mémoire. Les scripts pour nœud simple avec mémoire parallèle partagée (SMP pour Shared Memory Parallel) offriront une meilleure performance que les scripts pour plusieurs nœuds avec mémoire parallèle distribuée (DMP pour Distributed Memory Parallel) et devraient être utilisés autant que possible. Pour prévenir les problèmes de compatibilité, le module qui est chargé dans votre script devrait idéalement correspondre à la version employée pour générer le fichier en entrée. 

 [gra-login2:~/ansys/mechanical/demo] cat YOURAPDLFILE.inp | grep version
! ANSYS input file written by Workbench version 2019 R3

Ansys EDT

Ansys EDT peut être exécuté de manière interactive en mode batch (sans interface graphique) en démarrant d'abord une session salloc avec les options salloc --time=3:00:00 --tasks=8 --mem=16G --account=def- compte; copiez-collez ensuite la commande ansysedt complète donnée dans la dernière ligne de script-local-cmd.sh en vous assurant de spécifier manuellement $YOUR_AEDT_FILE.

Scripts pour l'ordonnanceur Slurm

Les tâches Ansys Electronic Desktop peuvent être soumises à la file d'attente d'une grappe avec la commande sbatch script-name.sh en utilisant l'un des scripts Slurm pour nœud simple suivants. En date de janvier 2023, ces scripts n'ont été testés que sur Graham et pourraient donc être mis à jour à l'avenir si nécessaire pour fonctionner avec d'autres grappes. Avant de les utiliser, spécifiez le temps de simulation, la mémoire, le nombre de cœurs et remplacez YOUR_AEDT_FILE par le nom de votre fichier d'entrée. Une liste complète des options de ligne de commande ansysedt peut être obtenue en démarrant Ansys EDT en mode graphique avec les commandes ansysedt -help ou ansysedt -Batchoptionhelp pour obtenir des fenêtres contextuelles graphiques déroulantes.

File : script-local-cmd.sh

#!/bin/bash

#SBATCH --account=account      # indiquer le nom du compte (def ou rrg)
#SBATCH --time=00-01:00        # indiquer la limite de temps (jj-hh:mm)
#SBATCH --mem=16G              # indiquer la mémoire totale (valeur de 0 pour allouer toute la mémoire du nœud de calcul)
#SBATCH --ntasks=8             # indiquer le nombre de cœurs (graham 32 ou 44, cedar 48, beluga 40, narval 64)
#SBATCH --nodes=1              # demander 1 nœud (ne pas modifier)

module load StdEnv/2020
module load ansysedt/2021R2

# supprimer la ligne suivante pour exécuter un test
cp -f $EBROOTANSYSEDT/AnsysEM21.2/Linux64/Examples/HFSS/Antennas/TransientGeoRadar.aedt .

# indiquer un fichier en entrée comme
YOUR_AEDT_FILE="TransientGeoRadar.aedt"

# supprimer les résultats précédents
rm -rf $YOUR_AEDT_FILE.* ${YOUR_AEDT_FILE}results

# ---- ne rien modifier sous cette ligne ---- #

echo -e "\nANSYSLI_SERVERS= $ANSYSLI_SERVERS"
echo "ANSYSLMD_LICENSE_FILE= $ANSYSLMD_LICENSE_FILE"
echo -e "SLURM_TMPDIR= $SLURM_TMPDIR on $SLURMD_NODENAME\n"

export KMP_AFFINITY=disabled
ansysedt -monitor -UseElectronicsPPE -ng -distributed -machinelist list=localhost:1:$SLURM_NTASKS \
-batchoptions "TempDirectory=$SLURM_TMPDIR HPCLicenseType=pool HFSS/EnableGPU=0" -batchsolve $YOUR_AEDT_FILE


File : script-local-opt.sh

#!/bin/bash

#SBATCH --account=account      # indiquer le nom du compte (def ou rrg)
#SBATCH --time=00-01:00        # indiquer la limite de temps (jj-hh:mm)
#SBATCH --mem=16G              # indiquer la mémoire totale (valeur de 0 pour allouer toute la mémoire du nœud de calcul)
#SBATCH --ntasks=8             # indiquer le nombre de cœurs  (graham 32 ou 44, cedar 48, beluga 40, narval 64)
#SBATCH --nodes=1              # demander 1 nœud (ne pas modifier)

module load StdEnv/2020
module load ansysedt/2021R2

# supprimer la ligne suivante pour exécuter un test
cp -f $EBROOTANSYSEDT/AnsysEM21.2/Linux64/Examples/HFSS/Antennas/TransientGeoRadar.aedt .

# indiquer un fichier en entrée comme
YOUR_AEDT_FILE="TransientGeoRadar.aedt"

# supprimer les résultats précédents
rm -rf $YOUR_AEDT_FILE.* ${YOUR_AEDT_FILE}results

# indiquer le nom du fichier d'options
OPTIONS_TXT="Options.txt"

# enregistrer le fichier des options
rm -f $OPTIONS_TXT
cat > $OPTIONS_TXT <<EOF
\$begin 'Config'
'TempDirectory'='$SLURM_TMPDIR'
'HPCLicenseType'='pool'
'HFSS/EnableGPU'=0
\$end 'Config'
EOF

# ---- ne rien modifier sous cette ligne ---- #

echo -e "\nANSYSLI_SERVERS= $ANSYSLI_SERVERS"
echo "ANSYSLMD_LICENSE_FILE= $ANSYSLMD_LICENSE_FILE"
echo -e "SLURM_TMPDIR= $SLURM_TMPDIR on $SLURMD_NODENAME\n"

export KMP_AFFINITY=disabled
ansysedt -monitor -UseElectronicsPPE -ng -distributed -machinelist list=localhost:1:$SLURM_NTASKS \
-batchoptions $OPTIONS_TXT -batchsolve $YOUR_AEDT_FILE


Mode graphique

Les programmes Ansys fonctionnent interactivement en mode graphique sur les nœuds de calcul des grappes ou sur les nœuds VDI de Graham.

Nœuds de calcul

Ansys peut être exécuté interactivement sur un nœud de calcul simple pour une durée pouvant aller jusqu'à 24 heures. C'est l'approche idéale pour tester des simulations intensives puisque tous les cœurs et la mémoire peuvent être demandés avec salloc comme décrit dans TigerVNC. Une fois la connexion faite à vncviewer, toutes les versions suivantes peuvent être lancées après que les modules requis ont été chargés. La barre verticale (|) délimite les commandes Ansys.

Fluids

module load StdEnv/2020 ansys/2022R1, ou
module load StdEnv/2020 ansys/2021R2, ou
module load StdEnv/2020 ansys/2021R1
unset SESSION_MANAGER
fluent -mpi=intel | cfx5
la barre verticale indique que vous pouvez choisir l'une ou l'autre
Remarque : ansys/2022R2 fluent ne fonctionne pas sur les nœuds de calcul présentement.
------------------------------------------------------------------------------------
module load StdEnv/2016 ansys/2020R2 (ou versions précédentes)
fluent | cfx5

Workbench

module load StdEnv/2020 ansys/2022R1, ou
module load StdEnv/2020 ansys/2021R2
runwb2
Remarque : ansys/2022R2 runwb2 ne fonctionne pas sur les nœuds de calcul présentement.
Pour une exécution parallèle, décochez la case Distributed dans le panneau Solve et spécifiez pour les cœurs (Cores) une valeur égale au nombre de CPU demandés avec salloc, moins 1.
Remarque : La plupart des menus déroulants et des icônes ne réagissent pas comme on pourrait s'y attendre quand on les survole avec la souris ou qu'on clique dessus. La liste suivante fournit des solutions de contournement pour donner un contrôle équivalent lorsque vous travaillez dans l'interface graphique de Workbench sur les nœuds de calcul d'une grappe :
o Pour accéder aux menus déroulants des éléments dans l'arborescence du projet à gauche, cliquez une fois avec le bouton gauche pour sélectionner l'élément, puis double-cliquez avec le bouton droit de la souris.
o Pour accéder aux menus déroulants des icônes supérieures avec de petites flèches vers le bas, cliquez une fois avec le bouton gauche pour sélectionner l'élément, puis double-cliquez avec le bouton gauche de votre souris. La petite flèche vers le bas de l'icône Solve qui permet d'accéder aux paramètres du processus de résolution est cependant une exception; pour y accéder, cliquez sur la petite flèche inclinée située dans le coin inférieur droit du panneau Solve.
o Le menu de gauche est souvent trop étroit pour montrer tout le texte des éléments déroulants. Cela peut être corrigé en faisant glisser la barre verticale de la fenêtre de gauche pour l'élargir. Ceci rendra aussi visibles les flèches déroulantes associées. La fenêtre de gauche peut être restaurée à son apparence par défaut en suivant la procédure du point précédent en spécifiant Home -> Layout -> Reset Layout.
o Si vous rencontrez des difficultés à défiler vers le bas pour cliquer sur File -> Close Mechanical ou si vous l'avez minimisé et souhaitez le restaurer pour l'afficher, alors faites un seul clic droit pour fermer ou un simple clic gauche sur le bouton Workbench situé en bas du cadre de l'interface graphique de tigervnc pour le resélectionner.
o Si Mechanical ne démarre pas complètement, fermez Ansys comme décrit dans le point précédent, puis quittez et redémarrez votre session salloc. La cause de cet inconvénient peut être une session Ansys précédente mal fermée qui a été exécutée dans la même session salloc.
------------------------------------------------------------------------------------
module load StdEnv/2016 ansys/2019R3 (non disponible sur Narval)
export PATH=$EBROOTNIXPKGS/bin:$PATH
runwb2
o Un seul clic droit pour accéder aux menus déroulants de l'arborescence du projet à gauche.
o Un seul clic gauche pour les menus déroulants supérieurs avec de petites flèches vers le bas.
o Cochez la case Distributed, spécifiez le nombre de cœurs (Cores) égal à la valeur demandée avec salloc moins 1.

Ansys EDT

module load CcEnv StdEnv/2020 ansysedt/2021R2
rm -rf ~/.mw (optionnel, pour retourner à la configuration initiale)
ansysedt

Ensight

module load StdEnv/2020 ansys/2022R2; A=222; B=5.12.6, ou
module load StdEnv/2020 ansys/2022R1; A=221; B=5.12.6, ou
module load StdEnv/2020 ansys/2021R2; A=212; B=5.12.6, ou
module load StdEnv/2020 ansys/2021R1; A=211; B=5.12.6, ou
module load StdEnv/2016 ansys/2020R2; A=202; B=5.12.6, ou
module load StdEnv/2016 ansys/2020R1; A=201; B=5.10.1, ou
module load StdEnv/2016 ansys/2019R3; A=195; B=5.10.1, ou
export LD_LIBRARY_PATH=$EBROOTANSYS/v$A/CEI/apex$A/machines/linux_2.6_64/qt-$B/lib
ensight -X

Remarque : ansys/2022R2 Ensight a été peu testé sur les nœuds de calcul; veuillez nous faire part des problèmes que vous rencontrez.

Nœuds VDI

Les programmes Ansys peuvent être exécutés jusqu'à 24 heures sur les nœuds Graham VDI en utilisant un maximum de 8 cœurs et 128 Go de mémoire. Le système VDI fournit une accélération GPU OpenGL, ce qui est idéal pour effectuer des tâches qui bénéficient de graphiques à haute performance. On peut utiliser VDI pour créer ou modifier des fichiers d'entrée de simulation, post-traiter des données ou visualiser des résultats de simulation. Pour commencer, connectez-vous à gra-vdi.computecanada.ca avec TigerVNC puis ouvrez une nouvelle fenêtre de terminal et démarrez l'une des versions de programme prises en charge comme indiqué ci-dessous. La barre verticale | est utilisée pour séparer les différentes commandes ANSYS.

Fluids

module load SnEnv ansys/2022R2; fluent
module load CcEnv StdEnv/2020 ansys/2022R2; cfx5
Remarque : icemcfd 2022R2 ne peut être utilisé tant que le serveur de licence n'est pas mis à jour.
------------------------------------------------------------------------------------
module load CcEnv StdEnv/2020 ansys/2022R1, ou
module load CcEnv StdEnv/2020 ansys/2021R2, ou
module load CcEnv StdEnv/2020 ansys/2021R1
unset SESSION_MANAGER
fluent | cfx5 | icemcfd
Remarque : Si icemcfd plante au démarrage, cliquez sur Settings -> Display -> X11.
------------------------------------------------------------------------------------
module load CcEnv StdEnv/2016 ansys/2020R2, ou
module load CcEnv StdEnv/2016 ansys/2020R1, ou
module load CcEnv StdEnv/2016 ansys/2019R3
export HOOPS_PICTURE=opengl
fluent | cfx5 | icemcfd

Workbench

module load SnEnv ansys/2022R2; runwb2
------------------------------------------------------------------------------------
module load CcEnv StdEnv/2020 ansys/2022R1
module load CcEnv StdEnv/2020 ansys/2021R2
runwb2
------------------------------------------------------------------------------------
module load SnEnv ansys/2021R1, ou
module load SnEnv ansys/2020R2
runwb2
------------------------------------------------------------------------------------
module load CcEnv StdEnv/2016 ansys/2020R1, ou
module load CcEnv StdEnv/2016 ansys/2019R3
export PATH=$EBROOTNIXPKGS/bin:$PATH
runwb2
Remarque : Les menus déroulants de gauche qui sont généralement par défaut contrôlés par le programme ne fonctionnent pas lorsque divers systèmes Ansys sont chargés, tels que Steady-State Thermal, Explicit Dynamics et ainsi de suite. Essayer d'utiliser les menus déroulants à plusieurs reprises sur gra-vdi peut faire planter Ansys de telle sorte que pkill -9 ansys doit être exécuté par la suite pour effacer complètement toutes les connexions persistantes au serveur de licences avant de redémarrer Workbench. Pour contourner le problème, quittez gra-vdi, puis ouvrez votre projet sous Workbench sur un nœud de calcul dans une session salloc. Apportez les modifications souhaitées, puis cliquez sur Home -> Save Project -> Close Mechanical, File -> Exit, puis quittez également votre session salloc. Revenez maintenant à gra-vdi où les paramètres modifiés devraient apparaître lorsque vous ouvrez de nouveau le projet sous Workbench. Ce message sera mis à jour si une solution à ce problème est trouvée.

Ansys EDT

module load SnEnv ansysedt/2023R1
ansysedt
*** OU ***
module load SnEnv ansys/2023R1
runwb2
------------------------------------------------------------------------------------
module load CcEnv StdEnv/2020 ansysedt/2021R2
ansysedt
------------------------------------------------------------------------------------
Pour retourner à la configuration initiale de Ansys EDT, lancez
rm -rf ~/.mw

Ensight

module load SnEnv ansys/2022R2, ou
module load SnEnv ansys/2022R1, ou
module load SnEnv ansys/2021R2, ou (voir la remarque)
module load SnEnv ansys/2021R1, ou (voir la remarque)
module load SnEnv ansys/2020R2, ou (voir la remarque)
module load SnEnv ansys/2020R1, ou
module load SnEnv ansys/2019R3, ou
module load SnEnv ansys/2019R2
ensight

unset SLURM_GTIDS


Au sujet de SSH Certains programmes d'interface graphique ANSYS peuvent être exécutés à distance sur un nœud de calcul d'une de nos grappes par redirection X via SSH vers votre ordinateur local. Contrairement à VNC, cette approche n'est ni testée ni prise en charge car elle repose sur un serveur d'affichage X correctement configuré pour votre système d'exploitation particulier OU sur la sélection, l'installation et la configuration d'un paquet d'émulateur client X approprié tel que MobaXterm. La plupart d'entre vous trouverez les temps de réponse interactifs inacceptables pour les tâches de menu de base, sans parler de l'exécution de tâches plus complexes telles que celles nécessitant du rendu graphique. Les temps d'attente pour démarrer des programmes avec interface graphique peuvent également être très longs, dépendant de votre connexion Internet. Dans un test par exemple, il a fallu 40 minutes pour démarrer complètement ansysedt sur SSH alors que vncviewer n'a pris que 34 secondes. Malgré la lenteur potentielle lors de la connexion via SSH pour exécuter des programmes avec interface graphique, cela peut toujours être intéressant si votre seul objectif est d'ouvrir une simulation et d'effectuer des opérations de menu de base ou d'exécuter des calculs. Ces étapes de base sont un point de départ : 1. ssh -Y username@graham.computecanada.ca; 2. salloc --x11 --time=1:00:00 --mem=16G --cpus-per-task =4 [--gpus-per-node=1] --account=def-mygroup; 3. une fois connecté à un nœud de calcul, essayez d'exécuter xclock. Si l'horloge apparaît sur votre bureau, chargez le module Ansys souhaité et essayez d'exécuter le programme.

Particularités selon le site d'utilisation

Licence SHARCNET

La licence Ansys de SHARCNET est gratuite pour une utilisation académique par les chercheurs et chercheuses de l'Alliance sur tout système de l'Alliance. Le logiciel installé n'a pas de limites de solveur ou de géométrie. Il peut uniquement être utilisé à des fins de recherche universitaire publiable. La licence a été mise à niveau de CFD vers MCS (Multiphysics Campus Solution) en mai 2020 et inclut les produits suivants : HF, EM, Electronics HPC, Mechanical et CFD comme décrit ici. Ni LS-DYNA ni Lumerical ne sont inclus. En juillet 2021, 1024 licences anshpc supplémentaires ont été ajoutées au groupe de 512. Avant d'exécuter de grands travaux parallèles, des tests de scalabilité doivent être exécutés pour une simulation donnée. Les tâches parallèles qui n'atteignent pas au moins 50% d'utilisation CPU peuvent être portées à l'attention de notre équipe technique par le système.

Depuis décembre 2023, chaque utilisateur peut exécuter 4 travaux en utilisant un total de 252 anshpc (plus 4 anshpc par tâche). Ainsi, les combinaisons de taille de tâches uniformes suivantes sont possibles : une tâche de 256 cœurs, deux tâches de 130 cœurs, trois tâches de 88 cœurs ou quatre tâches de 67 cœurs selon ( (252 + 4* nombre de tâches) / nombre de tâches). Puisque les meilleures performances parallèles sont généralement obtenues en utilisant des nœuds de calcul entiers, on peut déterminer le nombre de nœuds en divisant le nombre total de cœurs anshpc par le nombre de cœurs des nœuds de calcul. Par exemple, dans le cas de Graham qui a de nombreux nœuds de calcul à 32 cœurs (Broadwell) et quelques autres à 44 cœurs (Cascade), le nombre maximal de nœuds qui pourraient être demandés lors de l'exécution de tâches de différentes tailles sur des nœuds à 32 cœurs est : 256/32=8, 130/32=~4, 88/32=~2 ou 67/32=~2 pour exécuter 1, 2, 3 ou 4 tâches simultanées. Pour exprimer ceci sous forme d'équation, pour une taille de nœud de calcul donnée sur n'importe quelle grappe, le nombre de nœuds de calcul peut être calculé par (252 + (4*nombre de tâches) ) / (nombre de tâches*nombre de cœurs par nœud) ) en arrondissant vers le bas pour enfin déterminer le nombre total de cœurs à demander en multipliant le nombre de nœuds par le nombre de cœurs par nœud.

La licence de SHARCNET est disponible selon le principe du premier arrivé, premier servi. Si un nombre anormalement élevé de tâches Ansys était soumis un jour donné, certaines tâches pourraient échouer au démarrage si le nombre de licences disponibles est insuffisant. Ces événements sont cependant devenus très rares compte tenu de l'augmentation récente des licences anshpc. Si votre recherche nécessite plus de licences que SHARCNET ne peut fournir, une licence dédiée peut être achetée (et hébergée) sur un serveur de licences Ansys dans votre établissement local. Vous pouvez aussi acheter une licence directement auprès de SimuTech où des frais supplémentaires de 20% à l'échelle nationale doivent être ajoutés si la grappe où la licence sera utilisée n'est pas colocalisée dans votre établissement (par exemple la grappe Graham à Waterloo). Pour utiliser un serveur de licences ansys institutionnel local, reconfigurez le fichier ~/.licenses/ansys.lic sur la ou les grappes où vous souhaitez l'utiliser.

Fichier du serveur de licence

Pour utiliser la licence de SHARCNET, configurez votre fichier ansys.lic comme suit : 

[gra-login1:~/.licenses] cat ansys.lic
setenv("ANSYSLMD_LICENSE_FILE", "1055@license3.sharcnet.ca")
setenv("ANSYSLI_SERVERS", "2325@license3.sharcnet.ca")

Interroger le serveur de licence

Pour connaître le nombre de licences utilisées qui sont associées à votre nom d'utilisateur et le nombre de licences utilisées par tous les utilisateurs, lancez 

ssh graham.computecanada.ca
module load ansys
lmutil lmstat -c $ANSYSLMD_LICENSE_FILE -a | grep "Users of\|$USER"

Si vous remarquez que des licences sont utilisées sans justification avec votre nom d'utilisateur (ce qui peut se produire si Ansys n'a pas été correctement fermé sur gra-vdi), connectez-vous au nœud en cause, ouvrez une fenêtre de terminal et mettez fin au processus avec pkill -9 -e -u $USER -f "ansys" pour libérer vos licences. Prenez note que gra-vdi possède deux nœuds (gra-vdi3 et gra-vdi4) qui vous sont assignés au hasard quand vous vous connectez avec tigervnc; ainsi, avant de lancer pkill, il est nécessaire d'indiquer le nom complet de l'hôte (gra-vdi3.sharcnet.ca ou grav-vdi4.sharcnet.ca) quand vous vous connectez.

Modules VDI locaux

Lors de l'utilisation de gra-vdi, vous avez le choix de charger des modules Ansys à partir de notre environnement global (après avoir chargé CcEnv) ou de charger des modules Ansys installés localement sur la machine elle-même (après avoir chargé SnEnv). Les modules locaux peuvent être intéressants, car ils incluent certains programmes et versions d'Ansys non encore pris en charge par notre environnement standard. Lors du démarrage de programmes à partir de modules Ansys locaux, vous pouvez sélectionner le serveur de licences CMC ou accepter le serveur de licences SHARCNET par défaut. Les paramètres de ~/.licenses/ansys.lic ne sont présentement pas utilisés par les modules Ansys locaux, sauf lors du démarrage de runwb2 où ils remplacent les paramètres par défaut du serveur de licences SHARCNET. L'utilisation appropriée des programmes Ansys sur gra-vdi comprend : l'exécution interactive d'une seule tâche de test avec jusqu'à 8 cœurs et/ou 128Go de RAM; la création ou la modification de fichiers d'entrée pour la simulation; le post-traitement; ou la visualisation de données.

Modules Ansys

  1. Connectez-vous à gra-vdi.computecanada.ca avec TigerVNC.
  2. Ouvrez une fenêtre de terminal et chargez le module  :
    module load SnEnv ansys/2021R2, ou
    module load SnEnv ansys/2021R1, ou
    module load SnEnv ansys/2020R2, ou
    module load SnEnv ansys/2020R1, ou
    module load SnEnv ansys/2019R3
  3. Lancez un programme Ansys avec une des commandes suivantes :
    runwb2|fluent|cfx5|icemcfd|apdl
  4. Appuyez sur y et Enter pour accepter les conditions.
  5. Appuyez sur Enter pour accepter l'option n et utilisez le serveur de licence par défaut SHARCNET (dans le cas de runwb2, ~/.licenses/ansysedt.lic sera utilisé si trouvé, autrement ANSYSLI_SERVERS et ANSYSLMD_LICENSE_FILE seront utilisés s'ils sont configurés dans votre environnement, pour un autre serveur de licences distant, par exemple). Pour utiliser le serveur de licence de CMC, changez n pour y et appuyez sur Enter.

où cfx5 de l'étape 3 ci-dessus donne l'option de démarrer les composantes suivantes : 

   1) CFX-Launcher  (cfx5 -> cfx5launch)
   2) CFX-Pre       (cfx5pre)
   3) CFD-Post      (cfdpost -> cfx5post)
   4) CFX-Solver    (cfx5solve)

Modules ansysedt

  1. Connectez-vous à gra-vdi.computecanada.ca avec TigerVNC.
  2. Ouvrez une nouvelle fenêtre de terminal et chargez un module
    module load SnEnv ansysedt/2021R2, ou
    module load SnEnv ansysedt/2021R1
  3. Lancez Ansys Electromagnetics Desktop avec la commande ansysedt.
  4. Appuyez sur y et Enter pour accepter les conditions.
  5. Appuyez sur enter pour accepter l'option n et utiliser le serveur de licences SHARCNET par défaut (si présente, ~/.licenses/ansysedt.lic sera utilisée, autrement ANSYSLI_SERVERS et ANSYSLMD_LICENSE_FILE seront utilisés s'ils sont configurés dans votre environnement, par exemple pour un autre serveur à distance). Si vous remplacez n par y et appuyez sur Enter, le serveur de licences CMC sera utilisé.

Les préférences des fonctionnalités de licence précédemment configurées avec anslic_admin ne sont plus prises en charge suite à la mise à jour du serveur de licences SHARCNET du 9 septembre 2021. Si un problème de licence survient, essayez de supprimer le répertoire ~/.ansys de votre compte /home pour effacer les paramètres. Si les problèmes persistent, veuillez contacter notre soutien technique et fournir le contenu de votre fichier ~/.licenses/ansys.lic.

Additive Manufacturing

Configurez d'abord votre fichier ~/.licenses/ansys.lic pour l'orienter vers le serveur de licence où se trouve une licence valide pour Ansys Mechanical. Vous devez faire ceci sur tous les systèmes où vous utiliserez le logiciel.

Activer Additive

Pour activer Ansys Additive Manufacturing pour votre projet, effectuez les étapes suivantes :

Lancer Workbench

  • Lancez Workbench tel que décrit ci-dessus dans Mode graphique -> Nœuds de calcul -> Workbench.

Installer des extensions

  • Cliquez sur Extensions -> Install Extension.
  • Entrez /path/to/AdditiveWizard.wbex et cliquez sur Open : /cvmfs/restricted.computecanada.ca/easybuild/software/2017/Core/ansys/2019R3/v195/aisol/WBAddins/MechanicalExtensions/AdditiveWizard.wbex

Charger des extensions

  • Cliquez sur Extensions -> Manage Extensions et cochez Additive Wizard.
  • Cliquez sur l'onglet X de ACT Start Page pour revenir à l'onglet pour votre projet.

Exécuter Additive

Gra-vdi

Vous pouvez exécuter une seule tâche Ansys Additive Manufacturing sur gra-vdi en utilisant jusqu'à 16 cœurs comme suit :

  • Lancez Workbench sur gra-vdi comme décrit ci-dessus dans Additive Manufacturing -> Activer Additive.
  • Cliquez sur File -> Open et sélectionnez test.wbpj puis cliquez sur Open.
  • Cliquez sur View -> Reset workspace si votre écran est gris.
  • Lancez Mechanical, Clear Generated Data, sélectionnez Distributed, spécifiez Cores.
  • Cliquez sur File -> Save Project -> Solve.

Vérifiez l'utilisation :

  • Ouvrez un autre terminal et lancez top -u $USER OU ps u -u $USER | grep ansys.
  • Terminez les processus non nécessaires créés par des tâches précédentes avec pkill -9 -e -u $USER -f "ansys|mwrpcss|mwfwrapper|ENGINE".

Veuillez noter que des processus persistants peuvent bloquer les licences entre les sessions de connexion gra-vdi ou provoquer d'autres erreurs inhabituelles lors de la tentative de démarrage de l'interface graphique sur gra-vdi. Bien que cela soit rare, un processus peut rester en mémoire si une session d'interface graphique Ansys (Fluent, Workbench, etc.) n'est pas correctement terminée avant que vncviewer ne soit terminé manuellement ou de manière inattendue, par exemple en raison d'une panne de réseau temporaire ou d'un système de fichiers bloqué. Si ce dernier est à blâmer, les processus peuvent ne pas être tués tant que l'accès normal au disque n'est pas rétabli.

Grappe

Préparation du projet

Certaines préparations doivent être effectuées avant de soumettre un projet Additive nouvellement téléchargé dans la file d'attente d'une grappe avec sbatch scriptname. Pour commencer, ouvrez votre simulation avec l'interface graphique de Workbench (comme décrit ci-dessus dans Additive Manufacturing -> Activer Additive) dans le même répertoire que celui à partir duquel votre tâche sera soumise, puis enregistrez-la à nouveau. Assurez-vous d'utiliser la même version du module Ansys qui sera utilisé pour la tâche. Créez ensuite un script Slurm (comme expliqué dans le paragraphe pour Workbench dans la section Soumettre des tâches en lot sur nos grappes ci-dessus). Pour effectuer des études paramétriques, remplacez Update() par UpdateAllDesignPoints() dans le script Slurm. Déterminez le nombre optimal de cœurs et de mémoire en soumettant plusieurs courtes tâches de test. Pour éviter d'avoir à effacer manuellement la solution et recréer tous les points de conception dans Workbench entre chaque exécution de test, soit 1. remplacez Save(Overwrite=True) par Save (Overwrite=False); ou 2. enregistrez une copie du fichier YOURPROJECT.wbpj d'origine et du répertoire YOURPROJECT_files correspondant. Vous pouvez aussi créer puis exécuter manuellement un fichier de relecture sur la grappe dans le répertoire de cas de test entre chaque exécution, en notant qu'un seul fichier de relecture peut être utilisé dans différents répertoires en l'ouvrant dans un éditeur de texte et en modifiant le paramètre interne FilePath. 

module load ansys/2019R3
rm -f test_files/.lock
runwb2 -R myreplay.wbjn

Utilisation des ressources

Après quelques minutes, vous pouvez obtenir un instantané de l'utilisation des ressources par la tâche en cours d'exécution sur le ou les nœuds de calcul avec la commande srun. Le script pour 8 cœurs ci-dessous produit le résultat suivant où on remarque que l'ordonnanceur a choisi 2 nœuds. 

[gra-login1:~] srun --jobid=myjobid top -bn1 -u $USER | grep R | grep -v top
  PID USER   PR  NI    VIRT    RES    SHR S  %CPU %MEM    TIME+  COMMAND
22843 demo   20   0 2272124 256048  72796 R  88.0  0.2  1:06.24  ansys.e
22849 demo   20   0 2272118 256024  72822 R  99.0  0.2  1:06.37  ansys.e
22838 demo   20   0 2272362 255086  76644 R  96.0  0.2  1:06.37  ansys.e
  PID USER   PR  NI    VIRT    RES    SHR S  %CPU %MEM    TIME+  COMMAND
 4310 demo   20   0 2740212 271096 101892 R 101.0  0.2  1:06.26  ansys.e
 4311 demo   20   0 2740416 284552  98084 R  98.0  0.2  1:06.55  ansys.e
 4304 demo   20   0 2729516 268824 100388 R 100.0  0.2  1:06.12  ansys.e
 4305 demo   20   0 2729436 263204 100932 R 100.0  0.2  1:06.88  ansys.e
 4306 demo   20   0 2734720 431532  95180 R 100.0  0.3  1:06.57  ansys.e

Tests de scalabilité

Une fois la tâche complétée, son Job Wall-clock time peut être obtenu avec seff jobid. Cette valeur peut être utilisée pour effectuer des tests de scalabilité en soumettant de courtes tâches d'abord puis en doublant le nombre de cœurs. Tant que le Wall-clock time diminue d'environ 50%, vous pouvez continuer de doubler le nombre de cœurs.

Documentation

Pour obtenir la dernière version complète de la documentation depuis la version 19.2 :

  1. Connectez-vous à gra-vdi.computecanada.ca avec tigervnc tel que décrit dans Nœuds VDI.
  2. Si le navigateur Firefox ou l'application Ansys Workbench est active, fermez-les.
  3. Lancez Firefox avec Applications -> Internet -> Firefox.
  4. Ouvrez une nouvelle fenêtre de terminal avec Applications -> System Tools -> Mate Terminal.
  5. Lancez Workbench en entrant dans le terminal la commande module load CcEnv StdEnv ansys; runwb2.
  6. Dans le menu du haut pour Workbench cliquez sur Help -> Ansys Workbench Help; la page de documentation est immédiatement affichée dans Firefox.
  7. Puisque Workbench n'est plus nécessaire, fermez l'application en cliquant d'abord sur l'onglet du bas Unsaved Project - Workbench, ce qui fait afficher Workbench et cliquez ensuite sur File -> Exit.
  8. Au centre de la page de documentation, cliquez sur HOME qui se trouve à gauche de API DOCS.
  9. Faites défiler la fenêtre vers le bas pour faire afficher les icônes des produits et/ou l'ordre alphabétique des noms.
  10. Sélectionnez un produit pour faire afficher sa documentation; par défaut, celle de la dernière version est affichée; pour obtenir celle d'une autre version, cliquez sur le menu déroulant Release Year R qui se trouve près de la barre de recherche.
  11. Quand vous avez terminé, cliquez sur HOME.

Message Passing Interface

Retrieved from "https://docs.alliancecan.ca/mediawiki/index.php?title=Ansys/fr&oldid=135947"