Structure de pyro2

Pyro2 est majoritairement codé en langage python. Il est interfacé, grâce à f2py, avec de petites subroutines écrit en Fortran, augmentant la performance du code. L'extension numpy est utilisée afin de manipuler les matrices. Matplotlib est une extension du langage Python destinée à tracer et visualiser des données sous formes de graphiques.

Design du programme

Structure du répertoire

Chaque solveur a deux sous dossiers : problems et tests. Ces derniers contiennent les réglages des différents problèmes des solveurs et les résultats de référence pour les tests.

Votre variable d'environnement PYTHONPATH doit être réglée de manière à inclure le dossier pyro2/.

La structure générale se présente comme suit :

  • pyro2/ - C'est le répertoire de premier niveau. On y trouve le driver principal, pyro.py. Toutes les simulations pyro doivent être lancées à partir de ce répertoire.
    • advection/ - Solveur de l'équation d'advection linéaire. 
      • tests/ - Résultats de référence pour des tests de comparaison et régression​.
      • problems/ - Réglages du problème pour le solveur advection.
      • analysis/ - Scripts d'analyse pour traiter les fichiers de sortie.
      • compressible/ - Solveur de l'hydrodynamique compressible. 
        • problems/ - Réglages du problème pour le solveur compressible.
        • tests/ - Résultats de référence pour des tests de régression​.
      • incompressible/ - Solveur de l'hydrodynamique incompressible. 
        • problems/ - Réglages du problème pour le solveur compressible.
        • tests/ - Résultats de référence pour des tests de régression​.
      • diffusion/ - Solveur implicite du phénomène de diffusion thermique.
        • problems/ - Réglages du problème pour le solveur diffusion.
        • tests/ - Résultats de référence pour des tests de régression​.
      • lm_atm/ - Solveur pour les écoulements atmosphérique à bas nombre de Mach.
        • problems/ - Réglages du problème pour le solveur bas nombre de Mach.
        • tests/ - Résultats de référence pour des tests de régression​.
      • multigrid/ - Solveur s'appuyant sur la méthode des grilles.
        • problems/ - Réglages du problème pour le solveur bas nombre de Mach.
        • tests/ - Solutions de référence pour le solveur multigrid pour des tests de régression.
      • util/ - Modules utilisés par les routines pyro, incluant les paramètres de runtime et profilling.

Driver principal

Les solveurs utilisent le même driver, à savoir le script pyro.py. L'organisation du driver se fait comme suit :

  • analyse des paramètres de runtime
  • règle la grille (fonction initialize() du solveur)
    • initialise les données du problème (fonction init_data() du problème)
  • réalise les initialisations nécessaires pour l'état du fluide (fonction preevolve() du solveur)
  • évolue tant que t < tmax et n < max_steps
    • remplit les conditions limites (méthode fill_BC_all() de la classe CellCenterData2d)
    • calcule le pas de temps (fonction compute_timestep() du solveur)
    • évolue le système d'équation d'un pas de temps (fonction evolve() du solveur)
    • t = t + dt
    • écrit les résultats en sortie (output)
    • exécute la visualisation de la solution courante (fonction dovis() du solveur)
  • appelle la fonction finalize() du solveur pour sortir de quelconques informations utiles à la fin.

La fonction init_data() est utilisée pour remplir les données dans le patch object des réglages de chaque problème.

Compilation

Tout les solveurs se compilent par le script pyro.py. Trois arguments rentrent en compte: le nom du solveur, les réglages du problème à compiler avec ce solveur (définit dans le sous-dossier problems/ du solveur), et les fichier entrées (inputs) (définit dans le sous-dossier problems/ du solveur)

Par exemple, pour compiler le problème Sedov dans le solveur compresseur, la commande à taper est :

./pyro.py compressible sedov inputs.sedov

Cette commande est capable de chercher les fichiers d'entrée (inputs.sedov) dans compressible.problems/ (de même manière, vous pouvez indiquer le chemin des fichiers d'entrée).

N'importe quel paramètre de runtime peut aussi être spécifié, après la fichier d'entrée. Par exemple, pour empêcher la visualisation de l'évolution du programme de la commande précédente, la commande à taper est :

./pyro.py compressible sedov inputs.sedov vis.dovis=0

Variables d'exécution

Tous les solveurs utilisent les variables d'exécution suivantes :

[driver]
max_steps nombre maximal d'étape lors de la simulation
tmax

temps jusqu'auquel la simulation évolue

init_tstep_factor

quantité à soustraire au premier pas de temps. Cela permet au code de monter au pas de temps CFL doucement  

max_dt_change facteur maximal par lequel le pas de temps peut augmenter d'une itération à une autre
[io]
basename préfixe descriptif à utiliser pour les fichiers de sortie
dt_out intervalle de temps entre l'écriture de fichiers de sortie
n_out nombre de pas de temps l'écriture de fichiers de sortie
[vis]
dovis permet (1) ou empêche (2) la visualisation du runtime
store_images si 1, écrit les fichiers en PNG en simultané avec la visualisation du runtime 
n_out nombre de pas de temps entre l'écriture de fichiers de sortie
[mesh]
xmin plus petite coordonnée de l'axe x du domaine
xmax plus grande coordonnée de l'axe x du domaine
ymin plus petite coordonnée de l'axe y du domaine
ymax plus grande coordonnée de l'axe y du domaine
xlboundary description du type de limite à xmin
xrboundary description du type de limite à xmax
ylboundary description  du type de limite à ymin
yrboundary description  du type de limite à ymax
nx nombre de mailles dans la direction des x
ny nombre de mailles dans la direction des y

Exploitation des fichiers de sortie

Il existe plusieurs fonctions pour exploiter les fichiers de sortie, en voici un rapide aperçu. Ces fonctions sont expliquées plus en détails dans la partie Analyse des données. 

  • compare.py : ce script permet de comparer point par point deux graphes et présente les différences. Cette fonction se rend utile pour des simulations afin de voir si le code affecte la solution. Plusieurs problèmes ont des résultats de référence (tirés de la littérature) préstockés dans le dossier /tests des solveurs. Par exemple, pour comparer les résultats post-simualtion du problème de cisaillement en cas incompressible aux résultats de référence tirés de la littérature, nous pourrions rentrer la commande :
./compare.py shear_128_0216.pyro incompressible/tests/shear_128_0216.pyro
  • plot.py : ce script utilise la routine dovis() d'un solveur pour tracer des résultats (output file). Par exemple, pour tracer les données du fichier de sortie shear_128_0216.pyro du problème de cisaillement en cas incompressible, nous rentrerions la commande : 
./plot.py -o image.png incompressible shear_128_0216.pyro

où l'option "-o" permet de spécifier le nom du fichier de sortie. 

Ajout d'un problème

La façon la plus facile d'ajouter un problème est de copier le réglage d'un problème déjà existant dans le solveur que vous souhaitez utiliser (dans son sous-dossier problems/). Trois fichiers différents doivent être copier :

  • problem.py : la routine d'initialisation principale. 
  • _problem.defaults : fichier contenant les paramètres de runtime et leurs défauts pour votre problème.
  • inputs.problem : fichier d'entrées qui est utilisé à l'exécution pour régler les paramètres du problème. Toutes sortes de paramètre peuvent être régler ici (taille de la grille, conditions limites, etc.)

Une fois le problème définit, vous devez ajouter le nom du problème à la liste __all__ dans le fichier __init__.py du sous-dossier problems/. Cela permettra à Python de connaître le problème.