Abaqus/fr

Abaqus FEA est un progiciel commercial pour l'analyse d'éléments finis et l'ingénierie assistée par ordinateur.

Votre licence

Des modules Abaqus sont disponibles sur nos grappes, mais vous devez posséder votre propre licence. Pour configurer votre compte sur les grappes que vous voulez utiliser, connectez-vous et créez sur chacune un fichier $HOME/.licenses/abaqus.lic qui contient les deux lignes suivantes, pour les versions 202X et 6.14.1 respectivement. Remplacez ensuite port@server par le numéro du port flexlm et l'adresse IP (ou le nom complet du domaine) de votre serveur de licence Abaqus.

File : abaqus.lic

prepend_path("ABAQUSLM_LICENSE_FILE","port@server")
prepend_path("LM_LICENSE_FILE","port@server")

Si votre licence n'est pas configurée pour une grappe en particulier, les administrateurs de systèmes des deux parties devront effectuer certaines modifications. Ceci est nécessaire pour que les ports flexlm et TCP de votre serveur Abaqus puissent être rejoints par tous les nœuds de calcul quand vos tâches dans la queue seront exécutées. Pour que nous puissions vous assister dans cette tâche, écrivez au soutien technique en indiquant

• le numéro du port flexlm
• le numéro du port statique
• l'adresse IP de votre serveur de licence Abaqus.

En retour vous recevrez une liste d'adresses IP et votre administrateur de système pourra ouvrir les pare-feu de votre serveur local pour que la grappe puisse se connecter via les deux ports. Une entente spéciale doit habituellement être négociée et signée avec SIMULIA pour qu'une telle licence puisse être utilisée à distance avec notre matériel.

Soumettre une tâche sur une grappe

Vous trouverez ci-dessous des prototypes de scripts Slurm pour soumettre des simulations parallèles sur un ou plusieurs nœuds de calcul en utilisant des fils et MPI. Dans la plupart des cas, il suffira d'utiliser un des scripts du répertoire de projet dans une des sections pour un nœud simple. Dans la dernière ligne des scripts, l'argument memory= est optionnel et sert aux tâches qui demandent beaucoup de mémoire ou qui posent problème; la valeur de déplacement de 3072Mo (offset) pourrait nécessiter un ajustement. Pour obtenir la liste des arguments en ligne de commande, chargez un module Abaqus et lancez abaqus -help | less.

Le script du répertoire de projet sous le premier onglet devrait suffire pour les tâches qui utilisent un nœud simple et qui ont une durée de moins d'une journée. Par contre, pour les tâches qui utilisent un nœud simple et qui ont une durée de plus d'une journée, vous devriez utiliser un des scripts de redémarrage. Dans le cas des tâches qui créent de gros fichiers de redémarrage, il est préférable que l'écriture se fasse sur le disque local avec la variable d'environnement SLURM_TMPDIR qui est utilisée dans les scripts sous les derniers onglets des sections Analyse standard et Analyse explicite. Les scripts de redémarrage continueront les tâches qui ont été terminées pour une quelconque raison. Ceci peut se produire si la tâche atteint la durée d'exécution maximum demandée avant d'être complète et qu'elle est tuée par la queue, ou si le nœud de calcul plante en raison d'un problème de matériel inattendu. D'autres types de redémarrage sont possibles en modifiant davantage le fichier d'entrée (non documentés ici) pour poursuivre une tâche ayant des étapes additionnelles ou en changeant l'analyse (consultez la documentation pour les détails particuliers à la version).

Les tâches qui exigent beaucoup de mémoire ou beaucoup de ressources de calcul (plus que la capacité d'un nœud simple) devraient utiliser les scripts MPI dans les sections pour nœuds multiples afin de distribuer le calcul sur un ensemble de nœuds arbitraires déterminé automatiquement par l'ordonnanceur. Avant de lancer des tâches de longue durée, il est recommandé d'exécuter de courts tests présentant peu de scalabilité pour déterminer la durée réelle d'exécution (et les exigences en mémoire) en fonction du nombre optimal de cœurs (2, 4, 8, etc.).

Analyse standard

Les solveurs prennent en charge la parallélisation avec fils et avec MPI. Des scripts pour chaque mode sont présentés sous les onglets pour l'utilisation d'un nœud simple et celle de nœuds multiples. Des scripts pour redémarrer une tâche qui utilise des nœuds multiples ne sont pas présentés pour l'instant.

Scripts pour un nœud simple

script du répertoire de projetscript de redémarrage, répertoire de projetscript du répertoire temporairescript de redémarrage, répertoire temporaire

File : "scriptsp1.txt"

#!/bin/bash
#SBATCH --account=def-group    # indiquer le nom du compte
#SBATCH --time=00-06:00        # indiquer la limite de temps (jours-heures:minutes)
#SBATCH --cpus-per-task=4      # indiquer le nombre de cœurs
#SBATCH --mem=8M               # indiquer la mémoire totale > 5M
#SBATCH --nodes=1              # ne pas modifier

module load StdEnv/2020        # plus récente version installée
module load abaqus/2021        # plus récente version installée

#module load StdEnv/2016       # supprimer le commentaire pour utiliser la commande
#module load abaqus/2020       # supprimer le commentaire pour utiliser la commande

unset SLURM_GTIDS
export MPI_IC_ORDER='tcp'
echo "LM_LICENSE_FILE=$LM_LICENSE_FILE"
echo "ABAQUSLM_LICENSE_FILE=$ABAQUSLM_LICENSE_FILE"

rm -f testsp1* testsp2*
abaqus job=testsp1 input=mystd-sim.inp \
   scratch=$SCRATCH cpus=$SLURM_CPUS_ON_NODE interactive \
   mp_mode=threads memory="$((${SLURM_MEM_PER_NODE}-3072))MB"

Pour écrire les données de redémarrage en incréments de N=12, le fichier en entrée doit contenir

*RESTART, WRITE, OVERLAY, FREQUENCY=12

Pour écrire les données de redémarrage pour un total de 12 incréments, entrez plutôt

*RESTART, WRITE, OVERLAY, NUMBER INTERVAL=12, TIME MARKS=NO

Pour vérifier l'information complète sur le redémarrage

egrep -i "step|start" testsp*.com testsp*.msg testsp*.sta

Certaines simulations peuvent être améliorées en ajoutant au bas du script la commande Abaqus

order_parallel=OFF

File : "scriptsp2.txt"

#!/bin/bash
#SBATCH --account=def-group    # indiquer le nom du compte
#SBATCH --time=00-06:00        # indiquer la limite de temps (jours-heures:minutes)
#SBATCH --cpus-per-task=4      # indiquer le nombre de cœurs
#SBATCH --mem=8G               # indiquer la mémoire totale > 5M
#SBATCH --nodes=1              # ne pas modifier

module load StdEnv/2020        # plus récente version installée
module load abaqus/2021        # plus récente version installée

unset SLURM_GTIDS
export MPI_IC_ORDER='tcp'
echo "LM_LICENSE_FILE=$LM_LICENSE_FILE"
echo "ABAQUSLM_LICENSE_FILE=$ABAQUSLM_LICENSE_FILE"

rm -f testsp2* testsp1.lck
abaqus job=testsp2 oldjob=testsp1 input=mystd-sim-restart.inp \
   scratch=$SCRATCH cpus=$SLURM_CPUS_ON_NODE interactive \
   mp_mode=threads memory="$((${SLURM_MEM_PER_NODE}-3072))MB"

Le fichier en entrée pour le redémarrage doit contenir

*HEADING
*RESTART, READ

File : "scriptst1.txt"

#!/bin/bash
#SBATCH --account=def-group    # indiquer le nom du compte
#SBATCH --time=00-06:00        # indiquer la limite de temps (jours-heures:minutes)
#SBATCH --cpus-per-task=4      # indiquer le nombre de cœurs
#SBATCH --mem=8G               # indiquer la mémoire totale > 5M
#SBATCH --nodes=1              # ne pas modifier

module load StdEnv/2020        # plus récente version installée
module load abaqus/2021        # plus récente version installée

unset SLURM_GTIDS
export MPI_IC_ORDER='tcp'
echo "LM_LICENSE_FILE=$LM_LICENSE_FILE"
echo "ABAQUSLM_LICENSE_FILE=$ABAQUSLM_LICENSE_FILE"
echo "SLURM_SUBMIT_DIR =" $SLURM_SUBMIT_DIR
echo "SLURM_TMPDIR = " $SLURM_TMPDIR

rm -f testst1* testst2*
cd $SLURM_TMPDIR
while sleep 6h; do
   cp -f * $SLURM_SUBMIT_DIR 2>/dev/null
done &
WPID=$!
abaqus job=testst1 input=$SLURM_SUBMIT_DIR/mystd-sim.inp \
   scratch=$SCRATCH cpus=$SLURM_CPUS_ON_NODE interactive \
   mp_mode=threads memory="$((${SLURM_MEM_PER_NODE}-3072))MB"
{ kill $WPID && wait $WPID; } 2>/dev/null
cp -f * $SLURM_SUBMIT_DIR

Pour écrire les données de redémarrage en incréments de N=12, le fichier en entrée doit contenir

*RESTART, WRITE, OVERLAY, FREQUENCY=12

Pour écrire les données de redémarrage pour un total de 12 incréments, entrez plutôt

*RESTART, WRITE, OVERLAY, NUMBER INTERVAL=12, TIME MARKS=NO

Pour vérifier l'information complète sur le redémarrage

egrep -i "step|start" testst*.com testst*.msg testst*.sta

File : "scriptst2.txt"

#!/bin/bash
#SBATCH --account=def-group    # indiquer le nom du compte
#SBATCH --time=00-06:00        # indiquer la limite de temps (jours-heures:minutes)
#SBATCH --cpus-per-task=4      # indiquer le nombre de cœurs
#SBATCH --mem=8G               # indiquer la mémoire totale > 5M
#SBATCH --nodes=1              # ne pas modifier

module load StdEnv/2020        # plus récente version installée
module load abaqus/2021        # plus récente version installée

unset SLURM_GTIDS
export MPI_IC_ORDER='tcp'
echo "LM_LICENSE_FILE=$LM_LICENSE_FILE"
echo "ABAQUSLM_LICENSE_FILE=$ABAQUSLM_LICENSE_FILE"
echo "SLURM_SUBMIT_DIR =" $SLURM_SUBMIT_DIR
echo "SLURM_TMPDIR = " $SLURM_TMPDIR

rm -f testst2* testst1.lck
cp testst1* $SLURM_TMPDIR
cd $SLURM_TMPDIR
while sleep 3h; do
   cp -f testst2* $SLURM_SUBMIT_DIR 2>/dev/null
done &
WHILEPID=$!
abaqus job=testst2 oldjob=testst1 input=$SLURM_SUBMIT_DIR/mystd-sim-restart.inp \
   scratch=$SCRATCH cpus=$SLURM_CPUS_ON_NODE interactive \
   mp_mode=threads memory="$((${SLURM_MEM_PER_NODE}-3072))MB"
{ kill $WPID && wait $WPID; } 2>/dev/null
cp -f testst2* $SLURM_SUBMIT_DIR

Le fichier en entrée pour le redémarrage doit contenir

*HEADING
*RESTART, READ

Script pour nœuds multiples

Si vous disposez d'une licence qui vous permet d'exécuter des tâches nécessitant beaucoup de mémoire et de calcul, le script suivant pourra effectuer le calcul avec MPI en utilisant un ensemble de nœuds arbitraires idéalement déterminé automatiquement par l'ordonnanceur. Un script modèle pour redémarrer des tâches sur nœuds multiples n'est pas fourni car son utilisation présente des limitations supplémentaires.

File : "scriptsp1-mpi.txt"

!/bin/bash
#SBATCH --account=def-group    # indiquer le nom du compte
#SBATCH --time=00-06:00        # indiquer la limite de temps (jours-heures:minutes)
# SBATCH --nodes=2             # préférable de laisser en commentaire
#SBATCH --ntasks=8             # indiquer le nombre de cœurs
#SBATCH --mem-per-cpu=16G      # indiquer la mémoire par cœur
#SBATCH --cpus-per-task=1      # ne pas modifier

module load StdEnv/2020        # plus récente version installée
module load abaqus/2021        # plus récente version installée

unset SLURM_GTIDS
export MPI_IC_ORDER='tcp'
echo "LM_LICENSE_FILE=$LM_LICENSE_FILE"
echo "ABAQUSLM_LICENSE_FILE=$ABAQUSLM_LICENSE_FILE"

rm -f testsp1-mpi*

unset hostlist
nodes="$(slurm_hl2hl.py --format MPIHOSTLIST | xargs)"
for i in `echo "$nodes" | xargs -n1 | uniq`; do hostlist=${hostlist}$(echo "['${i}',$(echo "$nodes" | xargs -n1 | grep $i | wc -l)],"); done
hostlist="$(echo "$hostlist" | sed 's/,$//g')"
mphostlist="mp_host_list=[$(echo "$hostlist")]"
export $mphostlist
echo "$mphostlist" > abaqus_v6.env

abaqus job=testsp1-mpi input=mystd-sim.inp \
  scratch=$SCRATCH cpus=$SLURM_NTASKS interactive mp_mode=mpi

Analyse explicite

Les solveurs prennent en charge la parallélisation avec fils et avec MPI. Des scripts pour chaque mode sont présentés sous les onglets pour l'utilisation d'un nœud simple et celle de nœuds multiples. Des modèles de scripts pour redémarrer une tâche qui utilise des nœuds multiples nécessitent plus de tests et ne sont pas présentés pour l'instant.

Scripts pour un nœud simple

script du répertoire de projetscript de redémarrage, répertoire de projetscript du répertoire temporairescript de redémarrage, répertoire temporaire

File : "scriptep1.txt"

#!/bin/bash
#SBATCH --account=def-group    # indiquer le nom du compte
#SBATCH --time=00-06:00        # indiquer la limite de temps (jours-heures:minutes)
#SBATCH --mem=8000M            # indiquer la mémoire totale > 5M
#SBATCH --cpus-per-task=4      # indiquer le nombre de cœurs > 1
#SBATCH --nodes=1              # ne pas modifier

module load abaqus/2021

unset SLURM_GTIDS
export MPI_IC_ORDER='tcp'
echo "LM_LICENSE_FILE=$LM_LICENSE_FILE"
echo "ABAQUSLM_LICENSE_FILE=$ABAQUSLM_LICENSE_FILE"

rm -f testep1* testep2*
abaqus job=testep1 input=myexp-sim.inp \
   scratch=$SCRATCH cpus=$SLURM_CPUS_ON_NODE interactive \
   mp_mode=threads memory="$((${SLURM_MEM_PER_NODE}-3072))MB"

Pour écrire les données de redémarrage pour un total de 12 incréments, le fichier en entrée doit contenir

*RESTART, WRITE, OVERLAY, NUMBER INTERVAL=12, TIME MARKS=NO

Pour vérifier l'information complète sur le redémarrage

egrep -i "step|restart" testep*.com testep*.msg testep*.sta

File : "scriptep2.txt"

#!/bin/bash
#SBATCH --account=def-group    # indiquer le nom du compte
#SBATCH --time=00-06:00        # indiquer la limite de temps (jours-heures:minutes)
#SBATCH --mem=8000M            # indiquer la mémoire totale > 5M
#SBATCH --cpus-per-task=4      # indiquer le nombre de cœurs > 1
#SBATCH --nodes=1              # ne pas modifier

module load abaqus/2021

unset SLURM_GTIDS
export MPI_IC_ORDER='tcp'
echo "LM_LICENSE_FILE=$LM_LICENSE_FILE"
echo "ABAQUSLM_LICENSE_FILE=$ABAQUSLM_LICENSE_FILE"

rm -f testep2* testep1.lck
for f in testep1*; do [[ -f ${f} ]] && cp -a "$f" "testep2${f#testep1}"; done
abaqus job=testep2 input=myexp-sim.inp recover \
   scratch=$SCRATCH cpus=$SLURM_CPUS_ON_NODE interactive \
   mp_mode=threads memory="$((${SLURM_MEM_PER_NODE}-3072))MB"

Le fichier en entrée ne requiert aucune modification pour le redémarrage de l'analyse.

File : "scriptet1.txt"

#!/bin/bash
#SBATCH --account=def-group    # indiquer le nom du compte
#SBATCH --time=00-06:00        # indiquer la limite de temps (jours-heures:minutes)
#SBATCH --mem=8000M            # indiquer la mémoire totale > 5M
#SBATCH --cpus-per-task=4      # indiquer le nombre de cœurs > 1
#SBATCH --nodes=1              # ne pas modifier

module load abaqus/2021

unset SLURM_GTIDS
export MPI_IC_ORDER='tcp'
echo "LM_LICENSE_FILE=$LM_LICENSE_FILE"
echo "ABAQUSLM_LICENSE_FILE=$ABAQUSLM_LICENSE_FILE"
echo "SLURM_SUBMIT_DIR =" $SLURM_SUBMIT_DIR
echo "SLURM_TMPDIR = " $SLURM_TMPDIR

rm -f testet1* testet2*
cd $SLURM_TMPDIR
while sleep 6h; do
   cp -f * $SLURM_SUBMIT_DIR 2>/dev/null
done &
WPID=$!
abaqus job=testet1 input=$SLURM_SUBMIT_DIR/myexp-sim.inp \
   scratch=$SCRATCH cpus=$SLURM_CPUS_ON_NODE interactive \
   mp_mode=threads memory="$((${SLURM_MEM_PER_NODE}-3072))MB"
{ kill $WPID && wait $WPID; } 2>/dev/null
cp -f * $SLURM_SUBMIT_DIR

Pour écrire les données de redémarrage pour un total de 12 incréments, le fichier en entrée doit contenir

*RESTART, WRITE, OVERLAY, NUMBER INTERVAL=12, TIME MARKS=NO

Pour vérifier l'information complète sur le redémarrage

egrep -i "step|restart" testet*.com testet*.msg testet*.sta

File : "scriptet2.txt"

#!/bin/bash
#SBATCH --account=def-group    # indiquer le nom du compte
#SBATCH --time=00-06:00        # indiquer la limite de temps (jours-heures:minutes)
#SBATCH --mem=8000M            # indiquer la mémoire totale > 5M
#SBATCH --cpus-per-task=4      # indiquer le nombre de cœurs > 1
#SBATCH --nodes=1              # ne pas modifier

module load abaqus/2021

unset SLURM_GTIDS
export MPI_IC_ORDER='tcp'
echo "LM_LICENSE_FILE=$LM_LICENSE_FILE"
echo "ABAQUSLM_LICENSE_FILE=$ABAQUSLM_LICENSE_FILE"
echo "SLURM_SUBMIT_DIR =" $SLURM_SUBMIT_DIR
echo "SLURM_TMPDIR = " $SLURM_TMPDIR

rm -f testet2* testet1.lck
for f in testet1*; do cp -a "$f" $SLURM_TMPDIR/"testet2${f#testet1}"; done
cd $SLURM_TMPDIR
while sleep 3h; do
   cp -f * $SLURM_SUBMIT_DIR 2>/dev/null
done &
WPID=$!
abaqus job=testet2 input=$SLURM_SUBMIT_DIR/myexp-sim.inp recover \
   scratch=$SCRATCH cpus=$SLURM_CPUS_ON_NODE interactive \
   mp_mode=threads memory="$((${SLURM_MEM_PER_NODE}-3072))MB"
{ kill $WPID && wait $WPID; } 2>/dev/null
cp -f  * $SLURM_SUBMIT_DIR

Le fichier en entrée ne requiert aucune modification pour le redémarrage de l'analyse.

Script pour nœuds multiples

File : "scriptep1-mpi.txt"

!/bin/bash
#SBATCH --account=def-group    # indiquer le nom du compte
#SBATCH --time=00-06:00        # indiquer la limite de temps (jours-heures:minutes)
# SBATCH --nodes=2             # préférable de laisser en commentaire
#SBATCH --ntasks=8             # indiquer le nombre de cœurs
#SBATCH --mem-per-cpu=16000M   # indiquer la mémoire par cœur
# SBATCH --nodes=2             # indiquer le nombre de nœuds (optionnel)
#SBATCH --cpus-per-task=1      # ne pas modifier

module load StdEnv/2020        # plus récente version installée
module load abaqus/2021        # plus récente version installée

unset SLURM_GTIDS
export MPI_IC_ORDER='tcp'
# supprimer le commentaire sur la ligne suivante si vous utilisez abaqus/2021
export I_MPI_HYDRA_TOPOLIB=ipl
echo "LM_LICENSE_FILE=$LM_LICENSE_FILE"
echo "ABAQUSLM_LICENSE_FILE=$ABAQUSLM_LICENSE_FILE"

rm -f testep1-mpi*

unset hostlist
nodes="$(slurm_hl2hl.py --format MPIHOSTLIST | xargs)"
for i in `echo "$nodes" | xargs -n1 | uniq`; do hostlist=${hostlist}$(echo "['${i}',$(echo "$nodes" | xargs -n1 | grep $i | wc -l)],"); done
hostlist="$(echo "$hostlist" | sed 's/,$//g')"
mphostlist="mp_host_list=[$(echo "$hostlist")]"
export $mphostlist
echo "$mphostlist" > abaqus_v6.env

abaqus job=testep1-mpi input=myexp-sim.inp \
  scratch=$SCRATCH cpus=$SLURM_NTASKS interactive mp_mode=mpi

Capacité de mémoire pour un nœud

Une estimation de la mémoire totale pour un nœud (--mem=) requise par Slurm pour qu'une simulation soit effectuée uniquement en mémoire vive (sans être virtualisée sur le disque scratch) se trouve dans le fichier de sortie Abaqus test.dat. Dans l'exemple suivant, la simulation exige une assez grande quantité de mémoire.

                   M E M O R Y   E S T I M A T E
  
 PROCESS      FLOATING PT       MINIMUM MEMORY        MEMORY TO
              OPERATIONS           REQUIRED          MINIMIZE I/O
             PER ITERATION           (MB)               (MB)
  
     1          1.89E+14             3612              96345

Pour effectuer une simulation en mode interactif et suivre la consommation de mémoire,

1) via SSH, connectez-vous à une grappe, obtenez une allocation sur un nœud de calcul (comme gra100) et lancez Abaqus.

[name@server ~]$ module load abaqus/6.14.1  OR  module load abaqus/2020
[name@server ~]$ unset SLURM_GTIDS

2) via SSH, connectez-vous de nouveau à la grappe puis au nœud de calcul et lancez top.

[name@server ~]$ ssh gra100
[name@server ~]$ top -u $USER

3) observez les colonnes VIRT and RES jusqu'à ce que des valeurs de mémoire maximales stables soient atteintes.

Pour respecter la valeur de MEMORY TO OPERATIONS REQUIRED MINIMIZE I/O (MRMIO), Abaqus doit disposer de la même quantité de mémoire physique non échangée (RES). Comme la RES est en général plus petite que la mémoire virtuelle (VIRT) par une quantité relativement constante pour une simulation donnée, il faut donc augmenter légèrement la mémoire du nœud demandée pour Slurm -mem=. Dans l'exemple ci-dessus, la surallocation a été codée en dur à la valeur conservative de 3072Mo sur la base de tests avec le solveur standard d'Abaqus. Pour éviter le long temps d'attente associé à beaucoup de MRMIO, il pourrait être avantageux de vérifier l'impact associé avec la réduction de la mémoire RES réservée à Abaqus à une valeur considérablement inférieure à celle de la MRMIO. Ceci peut se faire en diminuant la valeur de -mem= qui à son tour va déterminer une valeur artificiellement basse pour memory= dans la dernière ligne du script pour Slurm. Si vous faites ceci, assurez-vous que la RES ne tombe pas sous MINIMUM MEMORY REQUIRED (MMR) puisqu'Abaqus fermera par manque de mémoire (OOM pour Out Of Memory). Par exemple, si votre MRMIO est de 96Go, effectuez une série de courts tests avec #SBATCH --mem=8G, 16G, 32G, 64G jusqu'à ce que l'impact minimal sur la performance soit acceptable; notez que des valeurs plus petites feront en sorte qu'un espace scratch de plus en plus grand sera utilisé pour les fichiers temporaires.

Mode graphique

Abaqus peut être utilisé interactivement en mode graphique sur une grappe ou sur gra-vdi avec VCN.

Sur une grappe

1. Connectez-vous à un nœud de calcul (durée maximale 3 heures) avec TigerVNC.
2. Ouvrez une nouvelle fenêtre de terminal et entrez
module load StdEnv/2020 abaqus/2021
3. Lancez l'application avec
abaqus cae -mesa

Sur gra-vdi

1. Connectez-vous à un nœud VDI (durée maximale 24 heures) avec TigerVNC.
2. Ouvrez une nouvelle fenêtre de terminal et entrez un des énoncés suivants :
module load StdEnv/2016 abaqus/6.14.1
module load StdEnv/2016 abaqus/2020 ou
module load StdEnv/2020 abaqus/2021
3. Lancez l'application avec
abaqus cae

o Vérifier la disponibilité de la licence Il doit y avoir au moins une licence non utilisée pour que abaqus cae démarre, selon

abaqus licensing lmstat -c $ABAQUSLM_LICENSE_FILE -a | grep "Users of cae"

[gra-vdi3:~] abaqus licensing lmstat -c $ABAQUSLM_LICENSE_FILE -a | grep "Users of cae"
Users of cae:  (Total of 4 licenses issued;  Total of 4 licenses in use)

Then the following error messages will occur when you attempt to start abaqus cae:

[gra-vdi3:~] abaqus cae
ABAQUSLM_LICENSE_FILE=27050@license3.sharcnet.ca
/opt/sharcnet/abaqus/2020/Commands/abaqus cae
No socket connection to license server manager.
Feature:       cae
License path:  27050@license3.sharcnet.ca:
FLEXnet Licensing error:-7,96
For further information, refer to the FLEXnet Licensing documentation,
or contact your local Abaqus representative.
Number of requested licenses: 1
Number of total licenses:     4
Number of licenses in use:    2
Number of available licenses: 2
Abaqus Error: Abaqus/CAE Kernel exited with an error.

Particularités selon le site d'utilisation

Licence SHARCNET

SHARCNET offre une licence gratuite, mais qui n'a que 2 jetons cae et 35 jetons execute, avec une utilisation limitée à 10 jetons par utilisateur et 15 jetons par groupe. Dans le cas des groupes qui ont acheté des jetons dédiés, les limites d'utilisation des jetons gratuits sont ajoutées à leur réservation. Les jetons gratuits sont disponibles selon le principe du premier arrivé, premier servi et sont principalement destinés à des tests et à une utilisation légère pour vous permettre de décider d'acheter ou non des jetons dédiés. Les coûts des jetons dédiés sont d'environ 110̩$ CA par jeton de calcul et de 400$ CA par jeton d'interface; pour connaître le prix exact, écrivez au soutien technique. La licence peut être utilisée par les chercheuses et chercheurs de l'Alliance, mais uniquement sur du matériel SHARCNET. De même, les groupes qui achètent des jetons dédiés à exécuter sur le serveur de licences SHARCNET ne peuvent les utiliser que sur du matériel SHARCNET, y compris gra-vdi (pour exécuter Abaqus en mode graphique complet) et les grappes Graham ou Dusky (pour soumettre des travaux de traitement par lots à la file d'attente). Avant de pouvoir utiliser la licence, vous devez en demander l'accès au soutien technique. Dans votre courriel 1) mentionnez qu'il est destiné à être utilisé sur les systèmes SHARCNET et 2) copiez/collez la déclaration License Agreement ci-dessous avec votre nom complet et votre nom d'utilisateur aux emplacements indiqués. Veuillez noter que chaque utilisateur doit remplir ce formulaire, c'est-à-dire qu'il ne peut pas être fourni une seule fois pour un groupe; ceci inclut les chercheuses et chercheurs principaux qui ont acheté leurs propres jetons dédiés.

o Entente

----------------------------------------------------------------------------------
Subject: Abaqus SHARCNET Academic License User Agreement
</div>

This email is to confirm that i "_____________" with username "___________" will
only use “SIMULIA Academic Software” with tokens from the SHARCNET license server
for the following purposes:

1) on SHARCNET hardware where the software is already installed
2) in affiliation with a Canadian degree-granting academic institution
3) for education, institutional or instruction purposes and not for any commercial
   or contract-related purposes where results are not publishable
4) for experimental, theoretical and/or digital research work, undertaken primarily
   to acquire new knowledge of the underlying foundations of phenomena and observable
   facts, up to the point of proof-of-concept in a laboratory    
-----------------------------------------------------------------------------------

o Configurer le fichier de licence Configurez votre fichier de licence comme suit (pour utilisation uniquement sur les systèmes SHARCNET Graham, gra-vdi et Dusky).

[gra-login1:~] cat ~/.licenses/abaqus.lic
prepend_path("LM_LICENSE_FILE","27050@license3.sharcnet.ca")
prepend_path("ABAQUSLM_LICENSE_FILE","27050@license3.sharcnet.ca")

Si vos tâches se terminent anormalement et que le fichier de sortie de l'ordonnanceur contient le message d'erreur *** ABAQUS/eliT_CheckLicense rank 0 terminated by signal 11 (Segmentation fault), vérifiez si votre fichier abaqus.lic contient ABAQUSLM_LICENSE_FILE pour Abaqus/2020. Si le fichier de sortie contient License server machine is down or not responding etc., vérifiez si le fichier abaqus.lic contient LM_LICENSE_FILE pour Abaqus/6.14.1, comme montré. Puisque le fichier abaqus.lic montré contient les deux énoncés, vous ne devriez pas avoir ce problème. o Interroger le serveur de licences I) Pour connaître les tâches commencées et les tâches en attente sur le serveur de licence SHARCNET, par utilisateur, lancez

Query license server

Log into graham, load abaqus and then run one of the following:

ssh graham.alliancecan.ca
module load StdEnv/2020
module load abaqus

I) Check the SHARCNET license server for started and queued jobs:

abaqus licensing lmstat -c $LM_LICENSE_FILE -a | egrep "Users|start|queued"

II) Pour savoir si le serveur de licences SHARCNET a des réservations de produits par groupe d'acquisition, lancez

abaqus licensing lmstat -c $LM_LICENSE_FILE -a | egrep "Users|start|queued|RESERVATION"

III) Pour savoir si le serveur de licences SHARCNET montre une utilisation de cae ou de produits standards et particuliers, lancez

abaqus licensing lmstat -c $LM_LICENSE_FILE -a | grep "Users of" | egrep "cae|standard|explicit"

Quand la sortie de la requête I) ci-dessus indique qu'une tâche pour un nom d'utilisateur particulier est mise en file d'attente (queued), cela signifie qu'elle est entrée dans l'état d'exécution (R pour running) du point de vue de squeue -j jobid ou sacct -j jobid et est donc inactive sur un nœud de calcul en attente d'une licence. Cela aura le même impact sur la priorité de votre compte que si la tâche effectuait des calculs et consommait du temps CPU. Quand suffisamment de licences seront disponibles, la tâche en file d'attente sera lancée. En exemple, ce qui suit montre le serveur de licences et la file d'attente en sortie quand un utilisateur soumet deux tâches, mais quand seule la première tâche obtient suffisamment de licences pour démarrer :

[roberpj@dus241:~] sq
         JOBID     USER      ACCOUNT           NAME  ST  TIME_LEFT  NODES  CPUS  MIN_MEM  NODELIST (REASON) 
         29801  roberpj  def-roberpj  scriptep1.txt   R    2:59:18      1    12       8G   dus47 (None) 
         29802  roberpj  def-roberpj  scriptsp1.txt   R    2:59:33      1    12       8G   dus28 (None) 

[roberpj@dus241:~] abaqus licensing lmstat -c $LM_LICENSE_FILE -a | egrep "Users|start|queued|RESERVATION"
 Users of abaqus:  (Total of 78 licenses issued;  Total of 71 licenses in use)
     roberpj dus47 /dev/tty (v62.2) (license3.sharcnet.ca/27050 275), start Thu 8/27 5:45, 14 licenses
     roberpj dus28 /dev/tty (v62.2) (license3.sharcnet.ca/27050 729) queued for 14 licenses

o Spécifier les ressources pour la tâche Pour garantir une utilisation optimale de vos jetons Abaqus et de nos ressources, il est important de bien spécifier la mémoire et le ncpus requis dans votre script Slurm. Les valeurs peuvent être déterminées en soumettant quelques courts tests à la file d'attente, puis en vérifiant leur utilisation. Pour les travaux terminés (completed), utilisez seff JobNumber pour afficher le total pour Memory Utilized et Memory Efficiency; si Memory Efficiency est inférieure à ~90 %, diminuez en conséquence la valeur du paramètre #SBATCH --mem= dans votre script. Notez que la commande seff JobNumber affiche aussi les totaux pour CPU (time) Utilized et CPU Efficiency; si CPU Efficiency est inférieure à ~90 %, effectuez des tests de mise à l'échelle pour déterminer le nombre optimal de CPU pour une performance optimale; ensuite, mettez à jour la valeur #SBATCH --cpus-per-task= dans votre script. Pour les tâches en cours d'exécution (running), utilisez la commande srun --jobid=29821580 --pty top -d 5 -u $USER pour surveiller %CPU, %MEM et RES pour chaque processus parent d'Abaqus sur le nœud de calcul. Les colonnes %CPU et %MEM affichent le pourcentage d'utilisation par rapport au total disponible sur le nœud, tandis que la colonne RES affiche la taille de la mémoire résidente par processus (au format lisible par l'homme pour les valeurs supérieures à 1 Go). Pour plus d'information, voir Running_jobs/fr#Suivi_des_tâches comment suivre une tâche.

o Correspondance cœur-jeton

TOKENS 5  6  7  8  10  12  14  16  19  21  25  28  34  38
CORES  1  2  3  4   6   8  12  16  24  32  48  64  96 128

où TOKENS = floor[5 X CORES^0.422]

Licence du site Western

Cette licence peut uniquement être utilisée par les chercheuses et chercheurs de Western avec du matériel situé sur le campus de Western. Dusky est présentement la seule grappe qui réunit ces conditions. Graham et gra-vdi sont exclus puisqu'ils sont situés sur le campus de Waterloo. Pour savoir si vous pouvez utiliser cette licence, contactez l'administrateur du serveur de licences de Western <jmilner@robarts.ca>. Vous devrez fournir votre nom d'utilisateur et possiblement acheter des jetons (tokens). Si l'accès vous est accordé, configurez votre fichier abaqus.lic pour qu'il pointe sur le serveur de licences de Western.
o Configurer le fichier de licences

Configurez votre fichier de licence comme suit (pour utilisation uniquement sur Dusky).

[dus241:~] cat .licenses/abaqus.lic
prepend_path("LM_LICENSE_FILE","27000@license4.sharcnet.ca")
prepend_path("ABAQUSLM_LICENSE_FILE","27000@license4.sharcnet.ca")

Par la suite, soumettez votre tâche tel que décrit à la section Soumettre une tâche sur une grappe ci-dessus. Si un problème survient, écrivez au soutien technique en indiquant que vous utilisez la licence du site Western sur Dusky. Ajoutez le numéro de la tâche qui pose problème et copiez le ou les messages d'erreur s'il y a lieu.

Documentation en ligne

Vous pouvez consulter la documentation pour la plus récente version sur gra-vdi comme suit :

Préparation de votre compte

1. Connectez-vous à gra-vdi.com avec TigerVNC.
2. Sur gra-vdi, ouvrez une fenêtre de terminal et entrez firefox (appuyez sur Entrée).
3. Dans la barre d'adresse, entrez about:config (appuyez sur Entrée) -> cliquez sur le bouton I accept the risk.
4. Dans la barre de recherche, entrez unique et double-cliquez sur privacy.file_unique_origin pour changer true' en false.

Afficher la documentation

1. Connectez-vous à gra-vdi.com avec TigerVNC.
2. Sur gra-vdi, ouvrez une fenêtre de terminal et entrez firefox (appuyez sur Entrée).
3. Dans la barre de recherche, copiez-collez un des énoncés suivants :
   file:///opt/sharcnet/abaqus/2020/doc/English/DSSIMULIA_Established.htm, ou
   file:///opt/sharcnet/abaqus/2021/doc/English/DSSIMULIA_Established.htm
4. Cliquez sur un sujet, par exemple Abaqus -> Analysis -> Analysis Techniques -> Analysis Continuation Techniques.

Message Passing Interface