Ansys

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

Compatibilité des versions

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/2023R2
[name@server ~]$ $EBROOTANSYS/v232/licensingclient/linx64/lmutil lmstat -c $ANSYSLMD_LICENSE_FILE -S ansyslmd

Si vous chargez une différente version du module Ansys, il faut modifier le chemin pour la commande lmutil.

Fluent jobscriptPlusieurs nœuds (par cœur)

{{File |name=fluent_job.sh |lang="bash" |contents=

1. !/bin/bash
2. SBATCH --account=def-group # specify some account
3. SBATCH --time=00-06:00 # Time limit dd-hh:mm
4. SBATCH --nodes=2 # Number of compute nodes
5. SBATCH --cpus-per-task=32 # Number of cores per node
6. SBATCH --ntasks-per-node=1 # Do not change
7. SBATCH --mem=0 # All memory on full nodes

module load ansys/2019R3

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.

What's New

Ansys posts Product Release and Updates for the latest releases. Similar information for previous releases can generally be pulled up for various application topics by visiting the Ansys blog page and using the FILTERS search bar. For example searching on What’s New Fluent 2024 gpu pulls up a document with title What’s New for Ansys Fluent in 2024 R1? containing a wealth of the latest gpu support information. Specifying a version number in the Press Release search bar is also a good way to find new release information. At the time of this writing Ansys 2024R2 is the current release and will be installed when interest is expressed or there is evident need to support newer hardware or solver capabilities. To request a new version be installed submit a problem ticket.

Service Packs

Ansys regularly releases service packs to fix and enhance various issues with its major releases. Therefore starting with Ansys 2024 a separate ansys module will appear on the clusters with a decimal and two digits appearing after the release number whenever a service pack is been installed over the initial release. For example, the initial 2024 release without any service pack applied maybe loaded by doing module load ansys/2024R1 while a module with Service Pack 3 applied maybe loaded by doing module load ansys/2024R1.03 instead. If a service pack is already available by the time a new release is to be installed, then most likely only a module for that service pack number will be installed unless otherwise a requeste to install the initial release also is received.

Most users will likely want to load the latest module version equipped with latest installed service pack which can be achieved by simply doing module load ansys. While its not expected service packs will impact numerical results, the changes they make are extensive and so if computations have already been done with the initial release or an earlier service pack than some groups may prefer to continue using it. Having separate modules for each service pack makes this possible. Starting with Ansys 2024R1 a detailed description of what each service pack does can be found by searching this link for Service Pack Details. Future versions will presumably be similarly searchable by manually modifying the version number contained in the link.

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.

<tabs> <tab name="Plusieurs nœuds (par nœud)"> {{File |name=script-flu-bynode.sh |lang="bash" |contents=

1. !/bin/bash

<tab name="Multinode (by node)">

File : script-flu-bynode-intel.sh

#!/bin/bash

<div class="mw-translate-fuzzy">
#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
</div>

<div class="mw-translate-fuzzy">
module load StdEnv/2023
module load ansys/2023R2      # ou versions plus récentes (s’applique à toutes les grappes)
</div>

<div class="mw-translate-fuzzy">
#module load StdEnv/2020
#module load ansys/2019R3     # ou versions plus récentes (s'applique uniquement à narval)
#module load ansys/2021R2     # ou versions plus récentes (cedar, beluga, graham)
</div>

<div class="mw-translate-fuzzy">
rm -f cleanup* core*
</div>

# ------- do not change any lines below --------

if [[ "${CC_CLUSTER}" == narval ]]; then
 if [ "$EBVERSIONGENTOO" == 2020 ]; then
   module load intel/2021 intelmpi
   export INTELMPI_ROOT=$I_MPI_ROOT/mpi/latest
   export HCOLL_RCACHE=^ucs
 elif [ "$EBVERSIONGENTOO" == 2023 ]; then
   module load intel/2023 intelmpi
   export INTELMPI_ROOT=$I_MPI_ROOT
 fi
 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))

<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
</div>

<div class="mw-translate-fuzzy">
#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
</div>

<div class="mw-translate-fuzzy">
module load StdEnv/2023
module load ansys/2023R2      # ou versions plus récentes (s'applique à toutes les grappes)
</div>

<div class="mw-translate-fuzzy">
#module load StdEnv/2020
#module load ansys/2019R3     # ou versions plus récentes (s’applique uniquement à Narval)
#module load ansys/2021R2     # ou versions plus récentes (s’applique à Cedar, Béluga, Graham)
</div>

<div class="mw-translate-fuzzy">
rm -f cleanup* core*
</div>

# ------- do not change any lines below --------

if [[ "${CC_CLUSTER}" == narval ]]; then
 if [ "$EBVERSIONGENTOO" == 2020 ]; then
   module load intel/2021 intelmpi
   export INTELMPI_ROOT=$I_MPI_ROOT/mpi/latest
   export HCOLL_RCACHE=^ucs
 elif [ "$EBVERSIONGENTOO" == 2023 ]; then
   module load intel/2023 intelmpi
   export INTELMPI_ROOT=$I_MPI_ROOT
 fi
 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))

<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

Multinode (by node, narval)Multinode (by node, narval)

File : script-flu-bynode-openmpi.sh

#!/bin/bash

#SBATCH --account=def-group   # Specify account name
#SBATCH --time=00-03:00       # Specify time limit dd-hh:mm
#SBATCH --nodes=1             # Specify number of compute nodes
#SBATCH --ntasks-per-node=64  # Specify number of cores per node (narval 64 or less)
#SBATCH --mem=0               # Do not change (allocates all memory per compute node)
#SBATCH --cpus-per-task=1     # Do not change

module load StdEnv/2023       # Do not change
module load ansys/2023R2      # or newer versions (narval only)

MYJOURNALFILE=sample.jou      # Specify your journal file name
MYVERSION=3d                  # Specify 2d, 2ddp, 3d or 3ddp

# ------- do not change any lines below --------

export OPENMPI_ROOT=$EBROOTOPENMPI
export OMPI_MCA_hwloc_base_binding_policy=core
slurm_hl2hl.py --format ANSYS-FLUENT > /tmp/mf-$SLURM_JOB_ID
for i in `cat /tmp/mf-$SLURM_JOB_ID | uniq`; do echo "${i}:$(cat /tmp/mf-$SLURM_JOB_ID | grep $i | wc -l)" >> /tmp/machinefile-$SLURM_JOB_ID; done
NCORES=$((SLURM_NNODES * SLURM_NTASKS_PER_NODE * SLURM_CPUS_PER_TASK))

if [ "$SLURM_NNODES" == 1 ]; then
 fluent -g $MYVERSION -t $NCORES -affinity=0 -mpi=openmpi -pshmem -i $MYJOURNALFILE
else
 fluent -g $MYVERSION -t $NCORES -affinity=0 -mpi=openmpi -pib -cnf=/tmp/machinefile-$SLURM_JOB_ID -i $MYJOURNALFILE
fi

Multinode (by core, narval)Multinode (by core, narval)

File : script-flu-bycore-openmpi.sh

#!/bin/bash

#SBATCH --account=def-group   # Specify account name
#SBATCH --time=00-03:00       # Specify time limit dd-hh:mm
##SBATCH --nodes=1            # Uncomment to specify number of compute nodes (optional)
#SBATCH --ntasks=16           # Specify total number of cores
#SBATCH --mem-per-cpu=4G      # Specify memory per core
#SBATCH --cpus-per-task=1     # Do not change

module load StdEnv/2023       # Do not change     
module load ansys/2023R2      # or newer versions (narval only)

MYJOURNALFILE=sample.jou      # Specify your journal file name
MYVERSION=3d                  # Specify 2d, 2ddp, 3d or 3ddp

# ------- do not change any lines below --------

export OPENMPI_ROOT=$EBROOTOPENMPI
export OMPI_MCA_hwloc_base_binding_policy=core
slurm_hl2hl.py --format ANSYS-FLUENT > /tmp/mf-$SLURM_JOB_ID
for i in `cat /tmp/mf-$SLURM_JOB_ID | uniq`; do echo "${i}:$(cat /tmp/mf-$SLURM_JOB_ID | grep $i | wc -l)" >> /tmp/machinefile-$SLURM_JOB_ID; done
NCORES=$((SLURM_NTASKS * SLURM_CPUS_PER_TASK))

if [ "$SLURM_NNODES" == 1 ]; then
 fluent -g $MYVERSION -t $NCORES -affinity=0 -mpi=openmpi -pshmem -i $MYJOURNALFILE
else
 fluent -g $MYVERSION -t $NCORES -affinity=0 -mpi=openmpi -pib -cnf=/tmp/machinefile-$SLURM_JOB_ID -i $MYJOURNALFILE
fi

Multinode (by node, niagara)Multinode (by node, niagara)

File : script-flu-bynode-intel-nia.sh

#!/bin/bash

#SBATCH --account=def-group      # Specify account name
#SBATCH --time=00-03:00          # Specify time limit dd-hh:mm
#SBATCH --nodes=1                # Specify number of compute nodes
#SBATCH --ntasks-per-node=80     # Specify number cores per node (niagara 80 or less)
#SBATCH --mem=0                  # Do not change (allocate all memory per compute node)
#SBATCH --cpus-per-task=1        # Do not change (required parameter)

module load CCEnv StdEnv/2023    # Do not change
module load ansys/2023R2         # or newer versions (niagara only)

MYJOURNALFILE=sample.jou         # Specify your journal file name
MYVERSION=3d                     # Specify 2d, 2ddp, 3d or 3ddp

# These settings are used instead of your ~/.licenses/ansys.lic
LICSERVER=license3.sharcnet.ca   # Specify license server hostname
FLEXPORT=1055                    # Specify server flex port
INTEPORT=2325                    # Specify server interconnect port
VENDPORT=1793                    # Specify server vendor port

# ------- do not change any lines below --------

ssh nia-gw -fNL $FLEXPORT:$LICSERVER:$FLEXPORT      # Do not change
ssh nia-gw -fNL $INTEPORT:$LICSERVER:$INTEPORT      # Do not change
ssh nia-gw -fNL $VENDPORT:$LICSERVER:$VENDPORT      # Do not change
export ANSYSLMD_LICENSE_FILE=$FLEXPORT@localhost    # Do not change
export ANSYSLI_SERVERS=$INTEPORT@localhost          # Do not change

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

if [ ! -L "$HOME/.ansys" ]; then
  echo "ERROR: A link to a writable .ansys directory does not exist."
  echo 'Remove ~/.ansys if one exists and then run: ln -s $SCRATCH/.ansys ~/.ansys'
  echo "Then try submitting your job again. Aborting the current job now!"
elif [ ! -L "$HOME/.fluentconf" ]; then
  echo "ERROR: A link to a writable .fluentconf directory does not exist."
  echo 'Remove ~/.fluentconf if one exists and run: ln -s $SCRATCH/.fluentconf ~/.fluentconf'
  echo "Then try submitting your job again. Aborting the current job now!"
elif [ ! -L "$HOME/.flrecent" ]; then
  echo "ERROR: A link to a writable .flrecent file does not exist."
  echo 'Remove ~/.flrecent if one exists and then run: ln -s $SCRATCH/.flrecent ~/.flrecent'
  echo "Then try submitting your job again. Aborting the current job now!"
else
  mkdir -pv $SCRATCH/.ansys
  mkdir -pv $SCRATCH/.fluentconf
  touch $SCRATCH/.flrecent
  if [ "$SLURM_NNODES" == 1 ]; then
   fluent -g $MYVERSION -t $NCORES -affinity=0 -mpi=intel -pshmem -i $MYJOURNALFILE
  else
   fluent -g $MYVERSION -t $NCORES -affinity=0 -mpi=intel -pib -cnf=/tmp/machinefile-$SLURM_JOB_ID -i $MYJOURNALFILE
  fi
fi

</tabs>

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.

Plusieurs nœuds (par nœud + remise en attente)Plusieurs nœuds (par cœur + remise en attente)

File : script-flu-bynode+requeue.sh

#!/bin/bash

<div class="mw-translate-fuzzy">
#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
</div>

<div class="mw-translate-fuzzy">
module load StdEnv/2023
module load ansys/2023R2      # ou versions plus récentes (s'applique à toutes les grappes)
</div>

<div class="mw-translate-fuzzy">
#module load StdEnv/2020
#module load ansys/2019R3     # ou versions plus récentes (s’applique uniquement à Narval)
#module load ansys/2021R2     # ou versions plus récentes (s'applique à Cedar, Béluga, Graham)


#module load StdEnv/2020      # 
#module load ansys/2019R3     #
</div>

<div class="mw-translate-fuzzy">
rm -f cleanup* core*
</div>

# ------- do not change any lines below --------

if [[ "${CC_CLUSTER}" == narval ]]; then
 if [ "$EBVERSIONGENTOO" == 2020 ]; then
   module load intel/2021 intelmpi
   export INTELMPI_ROOT=$I_MPI_ROOT/mpi/latest
   export HCOLL_RCACHE=^ucs
 elif [ "$EBVERSIONGENTOO" == 2023 ]; then
   module load intel/2023 intelmpi
   export INTELMPI_ROOT=$I_MPI_ROOT
 fi
 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))

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

<div class="mw-translate-fuzzy">
#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
</div>

<div class="mw-translate-fuzzy">
module load StdEnv/2023
module load ansys/2023R2      # ou versions plus récentes (s'applique à toutes les grappes)
</div>

<div class="mw-translate-fuzzy">
#module load StdEnv/2020
#module load ansys/2019R3     # ou versions plus récentes (s’applique uniquement à Narval)
#module load ansys/2021R2     # ou versions plus récentes (s'applique à Cedar, Béluga, Graham)
</div>

<div class="mw-translate-fuzzy">
rm -f cleanup* core*
</div>

# ------- do not change any lines below --------

if [[ "${CC_CLUSTER}" == narval ]]; then
 if [ "$EBVERSIONGENTOO" == 2020 ]; then
   module load intel/2021 intelmpi
   export INTELMPI_ROOT=$I_MPI_ROOT/mpi/latest
   export HCOLL_RCACHE=^ucs
 elif [ "$EBVERSIONGENTOO" == 2023 ]; then
   module load intel/2023 intelmpi
   export INTELMPI_ROOT=$I_MPI_ROOT
 fi
 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))

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

Plusieurs nœuds (par nœud + redémarrage)Plusieurs nœuds (par cœur + redémarrage)

File : script-flu-bynode+restart.sh

#!/bin/bash

<div class="mw-translate-fuzzy">
#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
</div>

module load StdEnv/2023       # Do not change
module load ansys/2023R2      # Specify version (beluga, cedar, graham, narval)

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

MYVERSION=3d                        # Specify 2d, 2ddp, 3d or 3ddp
MYJOUFILE=sample.jou                # Specify your journal filename
MYJOUFILERES=sample-restart.jou     # Specify journal restart filename
MYCASFILERES=sample-restart.cas.h5  # Specify cas restart filename
MYDATFILERES=sample-restart.dat.h5  # Specify dat restart filename

# ------- do not change any lines below --------

if [[ "${CC_CLUSTER}" == narval ]]; then
 if [ "$EBVERSIONGENTOO" == 2020 ]; then
   module load intel/2021 intelmpi
   export INTELMPI_ROOT=$I_MPI_ROOT/mpi/latest
   export HCOLL_RCACHE=^ucs
 elif [ "$EBVERSIONGENTOO" == 2023 ]; then
   module load intel/2023 intelmpi
   export INTELMPI_ROOT=$I_MPI_ROOT
 fi
 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))

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

<div class="mw-translate-fuzzy">
#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
</div>

<div class="mw-translate-fuzzy">
module load StdEnv/2020       # s’applique à Cedar, Béluga, Graham
module load ansys/2021R2      # ou versions plus récentes
</div>

<div class="mw-translate-fuzzy">
#module load StdEnv/2020      # s’applique uniquement à Narval
#module load ansys/2019R3     # ou versions plus récentes
</div>

<div class="mw-translate-fuzzy">
rm -f cleanup* core*
</div>

# ------- do not change any lines below --------

if [[ "${CC_CLUSTER}" == narval ]]; then
 if [ "$EBVERSIONGENTOO" == 2020 ]; then
   module load intel/2021 intelmpi
   export INTELMPI_ROOT=$I_MPI_ROOT/mpi/latest
   export HCOLL_RCACHE=^ucs
 elif [ "$EBVERSIONGENTOO" == 2023 ]; then
   module load intel/2023 intelmpi
   export INTELMPI_ROOT=$I_MPI_ROOT
 fi
 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))

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

Fichier de journalisation (stable, cas)Fichier de journalisation (stable, cas + données)Fichier de journalisation (temporaire)

File : sample1.jou

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

; Overwrite files by default
/file/confirm-overwrite no

<div class="mw-translate-fuzzy">
; lire/écrire des fichiers CFF (common fluids format) [yes par défaut]
/file/cff-files no
</div>

<div class="mw-translate-fuzzy">
; lire les fichiers en entrée pour les cas et les données
/file/read-case-data FFF-in
</div>

<div class="mw-translate-fuzzy">
; itérations du solveur
/solve/iterate 1000
</div>

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

; écrire le dernier fichier 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"

; Fermez correctement Fluent
/exit

File : sample2.jou

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

; Overwrite files by default
/file/confirm-overwrite no

<div class="mw-translate-fuzzy">
; lire/écrire des fichiers CFF (common fluids format) [yes, par défaut]
/file/cff-files no
</div>

; lire les fichiers en entrée
/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"

; fermez correctement Fluent
exit

File : sample3.jou

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

; Overwrite files by default
/file/confirm-overwrite no

<div class="mw-translate-fuzzy">
; lire/écrire des fichiers CFF (common fluids format) [yes par défaut]
/file/cff-files no
</div>

; lire 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

<div class="mw-translate-fuzzy">
; 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
</div>

; 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 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

; indiquer le nombre maximal d'itérations par pas et le nombre de pas
;/solve/set/max-iterations-per-time-step 75
;/solve/dual-time-iterate 1000 ,
/solve/dual-time-iterate 1000 75

; 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

<div class="mw-translate-fuzzy">
; fermer correctement Fluent
exit

</tabs>

UDFs

The first step is to transfer your User-Defined Function or UDF (namely the sampleudf.c source file and any additional dependency files) to the cluster. When uploading from a windows machine be sure the text mode setting of your transfer client is used otherwise fluent won't be able to read the file properly on the cluster since it runs linux. The UDF should be placed in the directory where your journal, cas and dat files reside. Next add one of the following commands into your journal file before the commands that read in your simulation cas/dat files. Regardless of whether you use the Interpreted or Compiled UDF approach, before uploading your cas file onto the Alliance please check that neither the Interpreted UDFs Dialog Box or the UDF Library Manager Dialog Box are configured to use any UDF, this will ensure that when jobs are submitted only the journal file commands will be in control.

Interpreted

To tell fluent to interpret your UDF at runtime add the following command line into your journal file before the cas/dat files are read or initialized. The filename sampleudf.c should be replaced with the name of your source file. The command remains the same regardless if the simulation is being run in serial or parallel. To ensure the UDF can be found in the same directory as the journal file remove any managed definitions from the cas file by opening it in the gui and resaving either before uploading to the Alliance or opening it in the gui on a compute node or gra-vdi then resaving it. Doing this will ensure only the following command/method will be in control when fluent runs. To use a interpreted UDF with parallel jobs it will need to be parallelized as described in the section below.

define/user-defined/interpreted-functions "sampleudf.c" "cpp" 10000 no

Compiled

To use this approach your UDF must be compiled on an alliance cluster at least once. Doing so will create a libudf subdirectory structure containing the required libudf.so shared library. The libudf directory cannot simply be copied from a remote system (such as your laptop) to the Alliance since the library dependencies of the shared library will not be satisfied resulting in fluent crashing on startup. That said once you have compiled your UDF on one Alliance cluster you can transfer the newly created libudf to any other Alliance cluster providing your account there loads the same StdEnv environment module version. Once copied, the UDF can be used by uncommenting the second (load) libudf line below in your journal file when submitting jobs to the cluster. Both (compile and load) libudf lines should not be left uncommented in your journal file when submitting jobs on the cluster otherwise your UDF will automatically (re)compiled for each and every job. Not only is this highly inefficient, but also it will lead to racetime-like build conflicts if multiple jobs are run from the same directory. Besides configuring your journal file to build your UDF, the fluent gui (run on any cluster compute node or gra-vdi) may also be used. To do this one would navigate to the Compiled UDFs Dialog Box, add the UDF source file and click Build. When using a compiled UDF with parallel jobs your source file should be parallelized as discussed in the section below.

define/user-defined/compiled-functions compile libudf yes sampleudf.c "" ""

and/or

define/user-defined/compiled-functions load libudf

Parallel

Before a UDF can be used with a fluent parallel job (single node SMP and multi node MPI) it will need to be parallelized. By doing this we control how/which processes (host and/or compute) run specific parts of the UDF code when fluent is run in parallel on the cluster. The instrumenting procedure involves adding compiler directives, predicates and reduction macros into your working serial UDF. Failure to do so will result in fluent running slow at best or immediately crashing at worst. The end result will be a single UDF that runs efficiently when fluent is used in both serial and parallel mode. The subject is described in detail under Part I: Chapter 7: Parallel Considerations of the Ansys 2024 Fluent Customization Manual which can be accessed here.

DPM

UDFs can be used to customize Discrete Phase Models (DPM) as described in Part III: Solution Mode | Chapter 24: Modeling Discrete Phase | 24.2 Steps for Using the Discrete Phase Models| 24.2.6 User-Defined Functions of the 2024R2 Fluent Users Guide and section Part I: Creating and Using User Defined Functions | Chapter 2: DEFINE Macros | 2.5 Discrete Phase Model (DPM) DEFINE Macros of the 2024R2 Fluent Customization Manual available here. Before a DMP based UDF can be worked into a simulation, the injection of a set of particles must be defined by specifying "Point Properties" with variables such as source position, initial trajectory, mass flow rate, time duration, temperature and so forth depending on the injection type. This can be done in the gui by clicking the Physics panel, Discrete Phase to open the Discrete Phase Model box and then clicking the Injections button. Doing so will open an Injections dialog box where one or more injections can be created by clicking the Create button. The "Set Injection Properties" dialog which appears will contain an "Injection Type" pulldown with first four types available are "single, group, surface, flat-fan-atomizer". If you select any of these then you can then the "Point Properties" tab can be selected to input the corresponding Value fields. Another way to specify the "Point Properties" would be to read an injection text file. To do this select "file" from the Injection Type pulldown, specify the Injection Name to be created and then click the File button (located beside the OK button at the bottom of the "Set Injection Properties" dialog). Here either an Injection Sample File (with .dpm extension) or a manually created injection text file can be selected. To Select the File in the Select File dialog box that change the File of type pull down to All Files (*), then highlight the file which could have any arbitrary name but commonly likely does have a .inj extension, click the OK button. Assuming there are no problems with the file, no Console error or warning message will appear in fluent. As you will be returned to the "Injections" dialog box, you should see the same Injection name that you specified in the "Set Injection Properties" dialog and be able to List its Particles and Properties in the console. Next open the Discrete Phase Model Dialog Box and select Interaction with Continuous Phase which will enable updating DPM source terms every flow iteration. This setting can be saved in your cas file or added via the journal file as shown. Once the injection is confirmed working in the gui the steps can be automated by adding commands to the journal file after solution initialization, for example:

/define/models/dpm/interaction/coupled-calculations yes
/define/models/dpm/injections/delete-injection injection-0:1
/define/models/dpm/injections/create injection-0:1 no yes file no zinjection01.inj no no no no
/define/models/dpm/injections/list-particles injection-0:1
/define/models/dpm/injections/list-injection-properties injection-0:1

where a basic manually created injection steady file format might look like:

 $ cat  zinjection01.inj
 (z=4 12)
 ( x          y        z    u         v    w    diameter  t         mass-flow  mass  frequency  time name )
 (( 2.90e-02  5.00e-03 0.0 -1.00e-03  0.0  0.0  1.00e-04  2.93e+02  1.00e-06   0.0   0.0        0.0 ) injection-0:1 )

noting that injection files for DPM simulations are generally setup for either steady or unsteady particle tracking where the format of the former is described in subsection Part III: Solution Mode | Chapter 24: Modeling Discrete Phase | 24.3. Setting Initial Conditions for the Discrete Phase | 24.3.13 Point Properties for File Injections | 24.3.13.1 Steady File Format of the 2024R2 Fluent Customization Manual.

Ansys CFX

Scripts pour l'ordonnanceur Slurm

Plusieurs nœudsNœud simple

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.

Nœud simple (StdEnv/2020)

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

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.

Nœud simple (StdEnv/2020)Script pour plusieurs nœuds (StdEnv/2020)

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

Single node (command line)Nœud simple (fichier d&#039;options)

File : script-local-cmd.sh

#!/bin/bash

#SBATCH --account=account      # Specify your account (def or rrg)
#SBATCH --time=00-01:00        # Specify time (DD-HH:MM)
#SBATCH --mem=16G              # Specify memory (set to 0 to use all compute node memory)
#SBATCH --ntasks=8             # Specify cores (beluga 40, cedar 32 or 48, graham 32 or 44, narval 64)
#SBATCH --nodes=1              # Request one node (Do Not Change)

module load StdEnv/2020
module load ansysedt/2021R2

# Uncomment next line to run a test example:
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"

• Vérifier le nombre de licences (tâches) ANSYS Academic Research en utilisation par votre nom d'utilisateur (maximum 2 tâches en cours d'exécution).

Besides being able to run simulations in gui mode (as discussed in the Graphical usage section below) Ansys Rocky can also run simulations in non-gui (or headless) mode. Both modes support running Rocky with cpus only or with cpus and gpus. In the below section two sample slurm scripts are provided where each script would be submitted to the graham queue with the sbatch command as per usual. At the time of this writing neither script has been tested and therefore extensive customization will likely be required. Its important to note that these scripts are only usable on graham since the rocky module which they both load is only (at the present time) installed on graham (locally).

Slurm scripts

To get a full listing of command line options run Rocky -h on the command line after loading any rocky module (currently only rocky/2023R2 is available on graham with 2024R1 and 2024R2 to be added asap). In regards to using Rocky with gpus for solving coupled problems, the number of cpus you should request from slurm (on the same node) should be increased to a maximum until the scalability limit of the coupled application is reached. On the other hand, if Rocky is being run with gpus to solve standalone uncoupled problems, then only a minimal number of cpus should be requested that will allow be sufficient for Rocky to still run optimally. For instance only 2cpus or possibly 3cpus maybe required. Finally when Rocky is run with more than 4cpus then rocky_hpc licenses will be required which the SHARCNET license does provide.

CPU onlyGPU based

File : script-rocky-cpu.sh

#!/bin/bash

#SBATCH --account=account      # Specify your account (def or rrg)
#SBATCH --time=00-02:00        # Specify time (DD-HH:MM)
#SBATCH --mem=24G              # Specify memory (set to 0 to use all node memory)
#SBATCH --cpus-per-task=6      # Specify cores (graham 32 or 44 to use all cores)
#SBATCH --nodes=1              # Request one node (do not change)

module load StdEnv/2023
module load rocky/2023R2 ansys/2023R2   # only available on graham (do not change)   

Rocky --simulate “mysim.rocky” --resume=0 --ncpus=$SLURM_CPUS_PER_TASK --use-gpu=0

File : script-rocky-gpu.sh

#!/bin/bash

#SBATCH --account=account      # Specify your account (def or reg)
#SBATCH --time=00-01:00        # Specify time (DD-HH:MM)
#SBATCH --mem=24G              # Specify memory (set to 0 to use all node memory)
#SBATCH --cpus-per-task=6      # Specify cores (graham 32 or 44 to use all cores)
#SBATCH --gres=gpu:v100:2      # Specify gpu type : gpu quantity
#SBATCH --nodes=1              # Request one node (do not change)

module load StdEnv/2023
module load rocky/2023R2 ansys/2023R2   # only available on graham (do not change)

Rocky --simulate “mysim.rocky” --resume=0 --ncpus=$SLURM_CPUS_PER_TASK --use-gpu=1 --gpu-num=$SLURM_GPUS_ON_NODE

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

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/2023R2, ou

module load StdEnv/2023 ansysedt/2023R2

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

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

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 CcEnv StdEnv/2020

module load ansys/2021R1 (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

NOTE1: When running Mechanical in Workbench on gra-vdi be sure to tic Distributed in the upper ribbon Solver panel and specify a maximum value of 24 cores. When running Fluent on gra-vdi instead untic Distributed and specify a maximum value of 12 cores. Do not attempt to use more than 128GB memory otherwise Ansys will hit the hard limit and be killed. If you need more cores or memory then please use a cluster compute node to run your graphical session on (as described in the previous Compute nodes section above). When doing old pre-processing or post-processing work with Ansys on gra-vdi and not running calculation, please only use 4 cores otherwise hpc licenses will be checked out unnecessarily.

NOTE2: On very rare occasions the Ansys workbench gui will freeze or become unresponsive in some way. If this happens open a new terminal window and run pkill -9 -e -u $USER -f "ansys|fluent|mwrpcss|mwfwrapper|ENGINE|mono" to fully kill off Ansys. Likewise if Ansys crashes or vncviewer disconnect before Ansys could be shutdown cleanly then try running the pkill command if Ansys does not run normally afterwards. In general, if Ansys is not behaving properly and you suspect one of the aforementioned causes try pkill before opening a problem ticket.

Ansys EDT

Ouvrez une fenêtre de terminal et chargez le module avec

module load SnEnv ansysedt/2023R2, ou

module load SnEnv ansysedt/2021R2

Dans le terminal, entrez ansysedt et attendez que l'interface s'affiche.

Ceci doit être fait une seule fois :

cliquez sur Tools -> Options -> HPC and Analysis Options -> Options

dans le menu déroulant, changez HPC License pour Pool (pour utiliser plus de 4 cœurs)

cliquez sur OK

---------- EXEMPLES ----------

Pour copier dans votre compte les exemples Antennas de 2023R2 :

connectez-vous à une grappe (par exemple Graham)

module load ansysedt/2023R2

mkdir -p ~/Ansoft/$EBVERSIONANSYSEDT; cd ~/Ansoft/$EBVERSIONANSYSEDT; rm -rf Antennas

cp -a $EBROOTANSYSEDT/v232/Linux64/Examples/HFSS/Antennas ~/Ansoft/$EBVERSIONANSYSEDT

Pour faire exécuter un exemple :

ouvrez un fichier .aedt et cliquez sur HFSS -> Validation Check

(si la validation produit une erreur, fermez et ouvrez de nouveau la simulation autant de fois que nécessaire)

pour lancer la simulation, cliquez sur Project -> Analyze All

pour quitter sans sauvegarder la solution, cliquez sur File -> Close -> No

si le programme plante et ne repart pas, essayez les commandes suivantes :

pkill -9 -u $USER -f "ansys*|mono|mwrpcss|apip-standalone-service"

rm -rf ~/.mw (au lancement, ansysedt utilisera la configuration initiale)

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.

Since the best parallel performance is usually achieved by using all cores on packed compute nodes (aka full nodes), one can determine the number of full nodes by dividing the total anshpc cores with the compute node size. For example, consider Graham which has many 32-core (Broadwell) and some 44-core (Cascade) compute nodes, the maximum number of nodes that could be requested when running various size jobs on 32-core nodes assuming a 252 hpc core limit would be: 256/32=8, 130/32=~4, 88/32=~2 or 67/32=~2 to run 1, 2, 3 or 4 simultaneous jobs respectively. To express this in equation form, for a given compute node size on any cluster, the number of compute nodes can be calculated by ( 252 + (4*num_jobs) ) / (num_jobs*cores_per_node) ) then round down and finally determine the total cores to request by multiplying the even number of nodes by the number of cores_per_node.

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