Ansys

From Alliance 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 100% complete.
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 sur 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. Pour indiquer votre propre serveur de licence, créez un fichier nommé $HOME/.licenses/ansys.lic qui contient les deux lignes ci-dessous, où vous remplacez FLEXPORT, INTEPORT et LICSERVER par les valeurs de votre serveur.

FICHIER : ansys.lic
setenv("ANSYSLMD_LICENSE_FILE", "FLEXPORT@LICSERVER")
setenv("ANSYSLI_SERVERS", "INTEPORT@LICSERVER")

Les valeurs correspondant aux serveurs de licence CMC et SHARCNET se trouvent dans le tableau ci-dessous. Pour utiliser un différent serveur, voir Serveurs de licence locaux ci-dessous.

TABLEAU : Serveurs de licence préconfigurés
Licence Grappe LICSERVER FLEXPORT INTEPORT VENDPORT NOTICES
CMC beluga 10.20.73.21 6624 2325 s.o. aucune
CMC cedar 172.16.0.101 6624 2325 s.o. aucune
CMC graham 199.241.167.222 6624 2325 s.o. aucune
CMC narval 10.100.64.10 6624 2325 s.o. aucune
SHARCNET beluga/cedar/graham/gra-vdi/narval license3.sharcnet.ca 1055 2325 s.o. aucune
SHARCNET niagara localhost 1055 2325 1793 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 systèmes puissent communiquer avec votre serveur de licence, des modifications doivent être apportées aux pare-feu des deux côtés. Dans plusieurs cas, ceci est déjà possible et tout ce que vous avez à faire est d'obtenir de l'administrateur de votre serveur de licence Ansys local 1) le nom complet (hostname) du serveur; 2) le port flex (FLEXPORT) pour Ansys, habituellement 1055; 3) le port d'interconnexion (INTEPORT), habituellement 2325. Vous pouvez alors configurer votre fichier ansys.lic comme indiqué plus haut et, en théorie, utiliser le logiciel. Si par contre votre serveur de licence n'a jamais été configuré, vous devez aussi obtenir 4) le numéro du port statique (VENDPORT).
Faites parvenir tous ces renseignements au soutien technique et indiquez les grappes que vous utiliserez pour vos tâches Ansys. Nous ferons en sorte que le pare-feu de l'Alliance soit ouvert pour que les connexions de la licence d'Ansys puissent rejoindre votre serveur de licence. Nous vous ferons aussi parvenir des adresses IP pour que votre administrateur puisse ouvrir le pare-feu de votre côté pour que votre serveur reçoive les connexions de la licence par les ports appropriés (FLEXPORT, INTEPORT, VENDPORT).

Vérifier l'utilisation de la licence

Ansys offre l'outil lmutil pour vérifier les détails de l'utilisation de votre licence. Avant de l'utiliser, assurez-vous que votre ansys.lic est configuré. Lancez ensuite les commandes suivantes sur une grappe où vous pouvez travailler. 

[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. Ils fonctionneront sur toutes les grappes, mais sur Niagara, vous devrez peut-être faire certains ajustements.

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 plus récentes

if [[ "${CC_CLUSTER}" == narval ]]; 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

slurm_hl2hl.py --format ANSYS-FLUENT > /tmp/machinefile-$SLURM_JOB_ID
NCORES=$((SLURM_NNODES * SLURM_NTASKS_PER_NODE * 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


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 moins récentes

#module load StdEnv/2020      # s’applique uniquement à Narval
#module load ansys/2019R3     # ou versions plus récentes

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

if [[ "${CC_CLUSTER}" == narval ]]; 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

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


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 moins récentes

#module load StdEnv/2020      # s’applique uniquement à Narval
#module load ansys/2019R3     # ou versions plus récentes

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

if [[ "${CC_CLUSTER}" == narval ]]; 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

slurm_hl2hl.py --format ANSYS-FLUENT > /tmp/machinefile-$SLURM_JOB_ID
NCORES=$((SLURM_NNODES * SLURM_NTASKS_PER_NODE * 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 moins récentes

#module load StdEnv/2020      # s’applique uniquement à Narval
#module load ansys/2019R3     # ou versions plus récentes

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

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

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, sample.dat et sample.jou doit être présent. 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 sous-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, ce qui consomme 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 moins récentes

#module load StdEnv/2020      # s’applique uniquement à Narval
#module load ansys/2019R3     # ou versions plus récentes

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

if [[ "${CC_CLUSTER}" == narval ]]; 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

slurm_hl2hl.py --format ANSYS-FLUENT > /tmp/machinefile-$SLURM_JOB_ID
NCORES=$((SLURM_NNODES * SLURM_NTASKS_PER_NODE * 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; 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 moins récentes

#module load StdEnv/2020      # s’applique uniquement à Narval
#module load ansys/2019R3     # ou versions plus récentes

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

if [[ "${CC_CLUSTER}" == narval ]]; 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

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-dist.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             # 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 32 ou 48, Béluga 40, Narval 64)
#SBATCH --mem=0               # allouer toute la mémoire du nœud de calcul
#SBATCH --cpus-per-task=1     # ne pas modifier

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

module load ansys/2021R1      # ou versions plus récentes

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

# au besoin, ajouter des options à la ligne de commande
if [ "$CC_CLUSTER" = cedar ]; then
  cfx5solve -def YOURFILE.def -start-method "Open MPI Distributed Parallel" -par-dist $NNODES
else
  cfx5solve -def YOURFILE.def -start-method "Intel MPI Distributed Parallel" -par-dist $NNODES
fi
File : script-local.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 un nœud de calcul simple (ne pas modifier)
#SBATCH --ntasks-per-node=4   # indiquer le nombre de cœurs (jusqu'à 64 pour Narval)
#SBATCH --mem=16G             # indiquer 0 quand vous utilisez toute la mémoire du nœud 
#SBATCH --cpus-per-task=1     # ne pas modifier

module load StdEnv/2020       # s'applique à Béluga, Cedar, Graham, Narval
module load ansys/2021R1      # ou versions de module plus récentes

# au besoin, ajouter des options à la ligne de commande
if [ "$CC_CLUSTER" = cedar ]; then
  cfx5solve -def YOURFILE.def -start-method "Open MPI Local Parallel" -part $SLURM_CPUS_ON_NODE
else
  cfx5solve -def YOURFILE.def -start-method "Intel MPI Local Parallel" -part $SLURM_CPUS_ON_NODE
fi

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

Initialisez le fichier de projet avant de le soumettre pour la première fois.

  1. Connectez-vous à la grappe avec TigerVNC.
  2. Dans le même répertoire où se trouve le fichier de projet (YOURPROJECT.wbpj), lancez Workbench avec la même version du module Ansys qui a servi à créer le projet.
  3. Dans Workbench, ouvrez le projet avec File -> Open.
  4. Dans la fenêtre principale, faites un clic droit sur Setup et sélectionnez Clear All Generated Data.
  5. Dans la liste déroulante de la barre de menus du haut, cliquez sur File -> Exit pour sortir de Workbench.
  6. Dans la fenêtre contextuelle Ansys Workbench qui affiche The current project has been modified. Do you want to save it ? cliquez sur le bouton No.
  7. Quittez Workbench et soumettez la tâche avec un des scripts ci-dessous.

Pour ne pas écrire la solution quand une tâche en cours 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

Pour soumettre un fichier de projet à la queue, personaliser les scripts suivants et lancer la commande sbatch script-wbpj.sh.

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 (multinœuds non supporté)
##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 plus récents

if [ "$SLURM_NNODES" == 1 ]; then
  MEMPAR=0                               # Set to 0 for SMP (shared memory parallel)
else
  MEMPAR=1                               # Set to 1 for DMP (distributed memory parallel)
fi

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 à 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 ci-dessous. 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 avec vncviewer, toutes les versions suivantes peuvent être lancées après que les modules requis ont été chargés.

Fluids

module load StdEnv/2020
module load ansys/2021R1 (ou versions plus récentes)
fluent -mpi=intel, ou,
QTWEBENGINE_DISABLE_SANDBOX=1 cfx5
------------------------------------------------------------------------------------
module load StdEnv/2016
module load ansys/2020R2 (ou versions moins récentes)
fluent -mpi=intel, ou
QTWEBENGINE_DISABLE_SANDBOX=1 cfx5
o où QTWEBENGINE_DISABLE_SANDBOX=1 empêche cfx5 -> CFD-Post de planter au démarrage avec le message
[Unexpected end of transmission from GUI. Engine state was dumped ...]

Mapdl

module load StdEnv/2020
module load ansys/2021R2 (ou versions plus récentes)
mapdl -g, ou via le démarreur,
launcher --> cliquer sur le bouton RUN

Workbench

module load StdEnv/2020
module load ansys/2021R2 (ou versions plus récentes)
xfwm4 --replace & (nécessaire seulement si vous utilisez Ansys Mechanical)
export QTWEBENGINE_DISABLE_SANDBOX=1 (nécessaire seulement si vous utilisez CFD-Post)
runwb2
------------------------------------------------------------------------------------
module load StdEnv/2016 (non disponible sur Narval)
module load ansys/2019R3 (ou versions moins récentes)
export PATH=$EBROOTNIXPKGS/bin:$PATH
xfwm4 --replace & (nécessaire seulement si vous utilisez Ansys Mechanical)
export QTWEBENGINE_DISABLE_SANDBOX=1 (nécessaire seulement si vous utilisez CFD-Post)
runwb2
o où QTWEBENGINE_DISABLE_SANDBOX=1 empêche CFX -> Results de planter au démarrage avec le message
[Error! Application has terminated before command could be sent]

Remarques : Quand vous exécutez en parallèle un programme d'analyse comme Mechanical or Fluent sur un nœud simple, ne cochez pas la case Distributed et indiquez uin nombre de cœurs égal à votre session salloc, moins 1. Les menus déroulants du Ansys Mechanical Workbench ne répondent pas correctement. Comme solution, lancez xfwm4 --replace sur la ligne de commande avant de démarrer Workbench. Pour avoir xfwm4 par défaut, modifiez $HOME/.vnc/xstartup et remplacez mate-session par xfce4-session. Enfin, Fluent dans ansys/2022R2 ne fonctionne pas en ce moment sur les nœuds de calcul; utilisez une autre version.

Ansys EDT

Lancez une session interactive avec le format suivant de la commande salloc (pour spécifier les cœurs et la mémoire disponible) :
salloc --time=3:00:00 --nodes=1 --cores=8 --mem=16G --account=def-group
xfwm4 --replace & (appuyez deux fois sur Enter)
module load StdEnv/2020 ansysedt/2021R2, ou
module load StdEnv/2020 ansysedt/2023R1 (bientôt disponible)
ansysedt
o Cliquez sur Tools -> Options -> HPC and Analysis Options -> Edit, puis
1) supprimez la coche de la case Use Automatic Settings box (nécessaire une fois seulement)
2) sous l'onglet Machines, ne modifiez pas Cores (détecté automatiquement à partir de Slurm)
o Pour exécuter l'analyse interactive, cliquez sur Project -> Analyze All
o Exécutez la première configuration une autre fois rm -rf ~/.mw (optionnel)

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.

Rocky

module load rocky/2023R2 ansys/2023R2 (ou versions plus récentes)
Rocky (s'il existe, lit ~/licenses/ansys.lic, autrement utilise le serveur SHARCNET par défaut), ou
Rocky-int (sélectionnez interactivement le serveur CMC ou SHARCNET server; lit aussi ~/licenses/ansys.lic)
RockySolver (lancez Rocky à partir de la ligne de commande; ceci n'a pas été testé mais vous pouvez entrer "-h" pour help)
RockySchedular (gestionnaire de ressources pour soumettre plusieurs tâches sur le nœud courant)
o Rocky est présentement disponible uniquement sur gra-vdi et la grappe Graham (workbench n'est pas supporté par linux)
o La documentation se trouve sur /opt/software/rocky/2023R2/docs (que vous pouvez lire avec mupdf)
o La licence SHARCNET inclut Rocky qui est sans frais pour la recherche

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 CcEnv StdEnv/2020 ansys/2021R1 (ou versions plus récentes)
unset SESSION_MANAGER
fluent | cfx5 | icemcfd
o où la non configuration de SESSION_MANAGER empêche l'affichage du message Qt suivant au démarrage de fluent:
[Qt: Session management error: None of the authentication protocols specified are supported]
o Si le message suivant est affiché dans une fenêtre contextuelle au lancement de icemcfd ...
[Error segmentation violation - exiting after doing an emergency save]
... ne cliquez pas sur OK dans la fenêtre sinon icemcfd va planter; faites plutôt ceci (une seule fois)
cliquez sur Settings -> Display -> cochez X11 -> Apply -> OK -> File -> Exit
La fenêtre avec le message d'erreur ne devrait plus être affichée au démarrage de icemcfd.
------------------------------------------------------------------------------------
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

Mapdl

module load StdEnv/2020
module load ansys/2021R2 (ou versions plus récentes )
mapdl -g, ou via le démarreur,
unset SESSION_MANAGER; launcher --> cliquez sur le bouton RUN

Workbench

module load CcEnv StdEnv/2020 ansys/2021R2 (ou versions plus récentes)
export HOOPS_PICTURE=opengl
runwb2
o La commande export empêche l'affichage de l'avertissement suivant au démarrage de fluent
[Software rasterizer found, hardware acceleration will be disabled.]
Autrement, HOOPS_PICTURE peut être configuré une fois que workbench est lancé avec
Fluent Launcher --> Environment --> HOOPS_PICTURE=opengl (sans la ligne export)
------------------------------------------------------------------------------------
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

Remarques : Quand vous exécutez en parallèle un programme d'analyse comme Mechanical ou Fluent sur gra-vdi, ne cochez pas la case Distributed et indiquez un nombre de cœurs de moins de 12. Pour avoir plus de cœurs, utilisez plutôt un nœud de calcul. Si un programme Ansys refuse de fonctionner après une exécution précédente, il est possible que des processus soient gelés parce qu'il n'a pas été fermé correctement ou qu'il a été minimisé. Pour éliminer ces processus, lancez pkill -9 -e -u $USER -f "ansys|fluent|mwrpcss|mwfwrapper|ENGINE|mono" et lancez le programme de nouveau.

Ansys EDT

module load SnEnv ansysedt/2023R1, ou
module load SnEnv ansysedt/2021R2
ansysedt
Cliquez sur Tools -> Options -> HPC and Analysis Options -> Edit, puis
1) ne cochez pas la case Distributed (une seule fois)
2) sous l'onglet Machines, indiquez une valeur pour Cores de 16 ou moins
Pour exécuter une analyse interactive, cliquez sur Project -> Analyze All
Vous pouvez aussi forcer la configuration initiale avec rm -rf ~/.mw

Ensight

module load SnEnv ansys/2019R2 (or newer)
ensight

Rocky

module load clumod rocky/2023R2 CcEnv StdEnv/2020 ansys/2023R2 (ou versions plus récentes)
Rocky (s'il existe, lit ~/licenses/ansys.lic, autrement utilise le serveur SHARCNET par défaut), ou
Rocky-int (sélectionnez interactivement le serveur CMC ou SHARCNET server; lit aussi ~/licenses/ansys.lic)
RockySolver (lancez Rocky à partir de la ligne de commande; ceci n'a pas été testé mais vous pouvez entrer "-h" pour help)
RockySchedular (gestionnaire de ressources pour soumettre plusieurs tâches sur le nœud courant)
o Rocky est présentement disponible uniquement sur gra-vdi et la grappe Graham (workbench n'est pas supporté par linux)
o La documentation se trouve sur /opt/software/rocky/2023R2/docs (que vous pouvez lire avec mupdf)
o La licence SHARCNET inclut Rocky qui est sans frais pour la recherche

Problèmes avec 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 les systèmes de l'Alliance. Le logiciel installé n'a pas de limites de solveur ou de géométrie. La licence SHARCNET peut uniquement être utilisée à des fins de recherche universitaire publiable; la production de résultats à des fins commerciales privées est strictement interdite. 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.

En 2023 Rocky pour Linux a été ajouté, mais sans support pour Workbench. Puisque toutes nos grappes fonctionnent avec Linux, SpaceClaim ne peut pas être utilisé. La licence SHARCNET n'inclut pas LS-DYNA et Lumerical, mais ceux-ci peuvent être achetés but could purchased as an add-on that would work with the existing hpc licenses. 

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 2022, 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.

Si vous avez besoin de plus de cœurs que la licence SHARCNET rend disponibles à chaque utilisateur, votre groupe de recherche peut aussi acheter une licence directement 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 recherche faite à Waterloo qui n'utilise que Graham n'encourt pas ces frais puisque Graham se trouve physiquement sur le campus.

Vous pouvez aussi acheter votre propre licence Ansys auprès de CMC et utiliser leurs serveurs de licences distants. Ceci présente plusieurs avantages :

  • un serveur de licences institutionnel local n'est pas nécessaire,
  • une licence physique n'a pas besoin d'être obtenue à chaque renouvellement,
  • la licence peut être utilisée campus-solutions-cmc-00200-04847/ presque n'importe où, y compris à la maison, dans des établissements ou dans toutes les grappes de l'Alliance,
  • les directives de téléchargement et d'installation pour la version Windows d'Ansys sont fournies afin de permettre l'exécution de spaceclaim sur votre propre ordinateur (ceci n'est pas possible sur nos systèmes qui sont basés sur Linux).

Il existe cependant une limitation potentiellement sérieuse à prendre en compte : selon Ansys Quick Start Guides, un utilisateur d'Ansys peut exécuter une simulation sur un maximum de 64 cœurs.

Fichier du serveur de licence

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

[username@cluster:~] cat ~/.licenses/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

Nous décrivons ici comment obtenir l'extension ACT de Ansys Additive Manufacturing pour l'utiliser dans votre projet. Les étapes suivantes doivent être effectuées pour chaque version de module Ansys sur chacune des grappes où l'extension sera utilisée. Les extensions nécessaires à votre projet doivent aussi être installées sur la ou les grappes, tel que décrit ci-dessous. Si vous recevez des avertissements à l'effet que des extensions dont vous n'avez pas besoin sont manquantes, par exemple ANSYSMotion, désinstallez-les à partir de votre projet.

Télécharger l'extension

  • téléchargez AdditiveWizard.wbex à partir de https://catalog.ansys.com/
  • téléversez AdditiveWizard.wbex sur la grappe où vous allez l'utililser

Lancer Workbench

  • Voir la section Workbench dansMode graphique plus haut.
  • Dans l'interface Workbench, ouvrez votre fichier de projet avec File -> Open.

Ouvrir le gestionnaire d'extensions

  • Cliquez sur la page ACT Start pour faire afficher l'onglet de la page ACT Home.
  • Cliquez sur Manage Extensions pour ouvrir le gestionnaire d'extensions.

Installer l'extension

  • Cliquez sur la boîte avec le signe + sous la barre de recherche.
  • Sélectionnez et installez votre fichier AdditiveWizard.wbex.

Charger l'extension

  • Cliquez pour sélectionner la boîte AdditiveWizard, ce qui charge l'extension uniquement pour la session en cours.
  • Cliquez sur la flèche dans le coin droit au bas de la boîte AdditiveWizard et sélectionnez Load extension, ce qui charge l'extension pour la session en cours et pour les sessions futures.

Supprimer l'extension

  • Cliquez pour désélectionner la boîte AdditiveWizard box, ce qui supprime l'extension pour la session en cours.
  • Cliquez sur la flèche dans le coin droit au bas de la boîte AdditiveWizard et sélectionnez Do not load as default, ce qui empêche le chargement de l'extension pour les futures sessions.

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-la maintenant.
  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=146405"