Cette section montre comment utiliser de manière basique l'interpréteur de Metafor (Python). L'idéal étant de se documenter sur le site officiel de Python, je sais, par expérience, que personne ne s'y réfère. Python est un langage extrêmement puissant qui permet de construire un jeu de données de manière très pratique pour le développeur. Elle paraîtra cependant un peu fastidieuse pour le simple utilisateur du code (mais ne sommes nous pas des ingénieurs?).

Lorsque Metafor est lancé, une fenêtre apparaît:

On arrive alors dans “l'interpréteur de commandes”. Il s'agit d'un interpréteur Python intégré dans Metafor qui permet de lancer des commandes, un peu comme dans MATLAB.

Au dessus, on remarque la liste des restrictions sur l'exécutable (limite en temps, en nombre de noeuds, etc - ici, c'est une version full liée à une machine spécifique).

Après initialisation de Python, Metafor charge automatiquement le module toolbox.utilities qui contient une série de commandes très utiles (plus précisément, seules certaines fonctions de toolbox.utilities sont chargées pour éviter d'encombrer l'espace de noms “racine”).

Un jeu de données Metafor est une suite de commandes Python (on est loin de la convivialité d'une interface graphique de type Samcef Fields ou Abaqus CAE). Cette manière de faire permet cependant d'obtenir une puissance extraordinaire pour le développement de modèles numériques. Il est en effet possible d'utiliser toutes les fonctions de Python pour arriver à créer rapidement et paramétrer un problème. Dans ce contexte, les fonctions, les objets, les boucles, les structures conditionnelles peuvent être utilisées.

Un autre aspect intéressant de Python est sa possibilité d'interfacer du code compilé (C++) sans aucune intervention du programmeur (les modules wrap sont créés automatiquement à partir du source de Metafor). Python est donc l'outil idéal pour le développeur et pour l'utilisateur (averti).

Python est simple d'emploi. On peut par exemple l'utiliser comme calculatrice :

>>> a=2
>>> b=3
>>> c=a+b
>>> c
5
>>>

(attention: cela ne fonctionne sous cette forme que si vous n'utilisez pas “Metafor GUI” mais simplement “Metafor”. Sous “Metafor GUI”, la valeur de c est obtenue par la commande print c). Ce système permet de paramétrer les jeux de données de Metafor. Il est donc très important de définir (comme dans n'importe quel programme) un ensemble de variables (les paramètres du modèle) et de travailler avec ces entités algébriques.

Pour voir le contenu de la mémoire, utilisez dir()

>>>> dir()
['__builtins__', '__doc__', '__name__', 'a', 'b', 'c', 'getDomain', 'getPath', 
'loadFac', 'makeAnimation', 'meta', 'quit', 'restart', 'vizu']
>>>

On y voit les variables qu'on vient de créer et les fonctions de toolbox.utilities initialement importées (meta, vizu, …). builtins est un module contenant les fonctions de base de Python. Pour voir leur liste, on utilise a nouveau dir()

>>> dir(__builtins__)
['ArithmeticError', 'AssertionError', 'AttributeError', 'DeprecationWarning', 
'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False', 
'FloatingPointError',    'FutureWarning', 'IOError', 'ImportError', 
'IndentationError', 'IndexError ...

Le type des variables s'imprime par type(var). Chaque variable est typée mais, contrairement aux langages Fortran ou C, le type peut varier au cours du temps.

>>> a=4
>>> type(a)
<type 'int'>
>>> a='text'
>>> type(a)
<type 'str'>
>>>

Des types peuvent être créés par l'utilisateur par l'intermédiaire des classes. Metafor utilise, en plus de ses propres types, les types de base (flottant, string, entier, listes, tuples, etc). Des opérateurs de conversion (cast) existent. Par exemple int(2.3) donne 2. L'opérateur str(2.3) donne la chaîne de caractère “2.3”.

L'interpréteur permet de créer des fonctions. Ceci est très utile pour éviter notamment des couper/coller ou simplement pour écrire des algorithmes sous forme de scripts. Par exemple:

>>> def square(x): return x*x
...
>>> square(6)
36
>>>

Les fonctions sont un élément important dans l'élaboration d'un jeu de données. Elles permettent de définir un ensemble d'opérations complexes et de les appeler plusieurs fois (par le même module ou par des modules différents). Par exemple, si on veut définir un problème possédant plusieurs matrices de contact de même forme, il sera très utile de paramétrer la création d'une matrice (définition des points, lignes, etc) et de l'appeler plusieurs fois. Les matériaux peuvent aussi être assignés à l'aide d'une fonction, par exemple.

Python permet de définir des valeurs par défaut pour les paramètres d'une fonction:

def myfun(x, a=1, b=1, c=0):
    return a*x*x+b*x+c

où a, b et c sont des paramètres facultatifs. Par exemple, on peut appeler la fonction par:

y = myfun(3, b=2)

Dans ce cas, x=3, a=1, b=2 et c=0.

Une autre manière d'écrire cette fonction utilise les fonctions lambda:

myfun = lambda x, a=1, b=1, c=0 : a*x*x+b*x+c

Il est souvent utile de regrouper une série de fonctions ensemble dans un fichier pour former un module. Un module est défini par un fichier. Dans Metafor, chaque cas-test est défini dans un module. Par exemple, le cas-test nommé cont2 se trouve dans Metafor/apps/qs/cont2.py et est identifié par apps.qs.cont2 sous Python.

Python possède d'origine beaucoup de modules prédéfinis. Par exemple, le module math définit les fonctions mathématiques de base. Pour utiliser un module, on utilise import (par exemple import math). Pour voir le contenu d'un module, on utilise dir(module). Pour utiliser une fonction de math, on utilise le point (math.cos par exemple pour calculer un cosinus):

>> import math
>>> dir(math)
['__doc__', '__name__', 'acos', 'asin', 'atan', 'atan2', 'ceil', 'cos', 'cosh',
'degrees', 'e', 'exp', 'fabs', 'floor', 'fmod', 'frexp', 'hypot', 'ldexp', 'log'
, 'log10', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh']
>>> math.cos(0.1)
0.99500416527802582
>>>

Pour voir l'aide en ligne, c'est la commande help():

>>> help(math.cos)
Help on built-in function cos in module math:

cos(...)
    cos(x)
    
    Return the cosine of x (measured in radians).

help(math) liste toutes les fonctions du module math. Cette aide en ligne bien précieuse est disponible également pour tous les modules de Metafor.

Il est possible d'importer toutes les fonctions de math dans l'espace de nom courant en effectuant:

>>> from math import *
>>> cos(0.1)
0.99500416527802582
>>>

Dans ce cas, le prefixe math n'est plus nécessaire (mais des conflits peuvent survenir avec d'autres modules qui définiraient une fonction cos).

Dans le cas de Metafor, pour importer les classes du module Metafor, on utilise from wrap import *. On a ainsi accès aux fonctionnalités de Metafor dans Python. On peut aussi imaginer d'importer une liste de matériaux par la commande import toolbox.createMaterial. Dans ce cas, le module ne contient plus des fonctions mais des objets.

Python est orienté objets. Cela signifie qu'il est possible de créer des classes. Une classe est, en résumé, une structure de données à laquelle on associe des méthodes. Par exemple, imaginons qu'on veuille calculer la longueur d'un vecteur. On peut définir une fonction du type:

def vectLength(x,y,z):
    import math
    return math.sqrt(x*x+y*y+z*z)

Remarquons ici que les blocs d'instructions sont définis par l'indentation en Python (contrairement au C qui utilise les acolades). Finir un bloc se fait en diminuant l'indentation. Ceci peut paraître compliqué à première vue mais est très pratique à l'utilisation puisque les utilisateurs de Python sont obligés d'indenter leur code.

La fonction vectLength calcule la longueur du vecteur (x,y,z). Ce n'est pas de l' “orienté objets” (pas d'encapsulation, l'utilisateur manipule directement les composantes du vecteur). Pour transformer ce code en “orienté objets”, on peut créer une classe (c-à-d un nouveau “type”) qui représentera un vecteur:

class vector:
    def __init__(self,x,y,z):
        self.x=x
        self.y=y
        self.z=z
    def view(self):
        print 'x=',self.x, ' y=',self.y, ' z=',self.z     
    def length(self):
        import math
        return math.sqrt(self.x*self.x+self.y*self.y+self.z*self.z)

Nous avons défini 3 fonctions membres: init : le constructeur (voir plus bas), view() qui affiche le vecteur en utilisant la fonction Python print et length qui retourne la longueur. Chaque fonction membre est définie à l'intérieur de la classe (cfr l'indentation).

Calculer la longueur d'un vecteur revient à créer un vecteur par la commande :

>>> v=vector(1,1,1)

Cette commande appelle le constructeur de la classe vector (fonction membre init). Notez que la fonction est définie avec 4 paramètres dont le premier est self (équivaut au pointeur this du C++) et que l'appel se fait avec 3 paramètres (le pointeur self est passé de manière implicite).

>>> type(v)
<type 'instance'>
>>> v.view()
x= 1  y= 1  z= 1
>>> v.length()   
1.7320508075688772
>>>

Dans le cas de Metafor, l'utilisateur manipule des classes définies dans les modules contenus dans le répertoire wrap. Il est donc important de connaître la notion d'objet pour utiliser Metafor même si l'utilisateur peut écrire un jeu de données sans avoir recours à la création de ses propres objets.

Dans un jeu de données Metafor, certaines opérations peuvent être répétitives. Il est par exemple intéressant de pouvoir mailler les courbes portant les numéros 1 à 10. On utilise alors des boucles pour réduire la taille du fichier. Une boucle s'écrit de la manière suivante:

for i in (1,6,8,12):
    print 'i=',i

où les valeurs entre parenthèses forment un “tuple”. Cet exemple est une boucle où i vaudra successivement 1, 6, 8 et 12 (4 exécutions de la commande print).

Il est possible également d'utiliser des listes. Dans ce cas, on utilise des crochets au lieu des parenthèses. A la différence des tuples, les listes sont modifiables.

Pour créer une liste, il est souvent intéressant d'utiliser la fonction range(i,j,k) qui fonctionne comme i:k:j de Matlab et i j k de Bacon (Samcef).

>>> range(1,10,2)
[1, 3, 5, 7, 9]

Une liste peut être créée par définition:

[ x for x in range(100) if x%3==0 ]

donne tous les nombres divisibles par 3 de 0 à 99.

Il est parfois intéressant de paramétrer un jeu de données de manière complexe en utilisant des conditions. Par exemple, on peut définir par exemple un paramètre booléen useLinearMaterial qui permet de choisir entre un comportement linéaire ou non du matériau. Ce paramètre sera facile à modifier (puisque placé au début du fichier de données) et entrainera la création conditionnelle d'un matériau linéaire. Ce type de structure fait intervenir la commande if. Il s'utilise comme suit:

if x>100:
    print "x>100"
elif x>10:
    print "x>10"
else:
    print "x<=10"

• Les booléens “vrai” & “faux” se notent True et False (avec majuscule).

• Si on effectue une opération de division entre 2 entiers, Python réagit comme la plupart des langages compilés (C, Fortran): il effectue une division ENTIERE. Autrement dit 2/3 = 0 , par exemple. Pour obtenir un nombre flottant en sortie, on doit utiliser un flotant dans la division: soit 2.0/3, soit 2/3.0.

• Un nombre commençant par 0 est interprété en base octale: par exemple 012 donne 10 en décimal.

• La commande raw_input('message') permet de demander une valeur à l'utilisateur (utile pour faire une pause dans un jeu de données - par exemple lors d'une visualisation de maillage intermédiaire).

• La fonction print a,b,c imprime les objets a, b et c sur la même ligne. Il est souvent très intéressant d'utiliser cette fonction sur les objets de Metafor.

• La commande nulle s'appelle pass.

• Les commandes peuvent être écrites sur la même ligne en étant séparées par un point-virgule (comme en C).

• Les chaînes sont délimitées soit par des simples ('), doubles (“) ou triples guillements (”“”).

Ce document a montré la base de l'utilisation de Python dans le cadre de Metafor. Il est cependant très utile de lire d'autres sources d'informations pour compléter sa compréhension du langage. Des objets et des commandes plus complexes existent (dictionnaires, commandes I/O, commandes systèmes, expressions régulières, interface Tcl/Tk, etc) et peuvent être utilisées dans n'importe quel jeu de données pour améliorer sa lisibilité et son efficacité. N'hésitez pas à me contacter si vous êtes intéressé par ces aspects avancés.

Maintenant, vous en savez assez pour apprendre à utiliser

⇒ How to build my own FE model?