PySide Simplissimus : une application d'ingénierie

Le Qt Developer Network est un réseau de développeurs utilisant Qt afin de partager leur savoir sur ce framework. Vous pouvez le consulter en anglais.

Nokia, Qt, Qt Quarterly et leurs logos sont des marques déposées de Nokia Corporation en Finlande et/ou dans les autres pays. Les autres marques déposées sont détenues par leurs propriétaires respectifs.

Cet article est la traduction de Engineering Application.

Cette partie a failli débuter comme toutes les autres : un listing du programme avant tout. Cependant, après réflexion, il appert qu'il serait plus utile de ne pas les montrer, car trop longs. Voici donc une simple archive du programme, des fichiers de ressources, des fichiers de données d'exemples et des exemples de sortie.

Le programme est séparé en deux parties : la GUI, avec PySide, et le « mangeur de nombres », un module Python, d'ailleurs prévu pour être lançable directement en ligne de commande. C'est très utile lors du développement, puisqu'on peut travailler sur les deux parties de manière distincte. La partie GUI est deux fois plus grande que l'autre, le fichier truss.py (la GUI) fait 380 lignes, bien qu'une grande partie ne fasse que garder des comptes à jour. Ce n'est pas un gros programme intrinsèquement, il l'est suffisamment cependant pour n'être pas affiché ici.

En fait, beaucoup de parties de la GUI sont à mettre en parallèle avec les parties précédentes : la boîte À propos est identique, comme l'affichage de la licence. La GUI est construite à partir de deux QPlainTextEdit, placés dans un formulaire avec deux onglets. L'un est réservé à l'entrée, l'autre à la sortie. L'onglet de sortie et l'éditeur de texte sont en lecture seule. On ne veut pas charger des données ou d'autres informations dans la sortie, on ne pourra qu'exporter les résultats de l'analyse.

L'analyse est l'une des structures les plus simples de l'ingénierie : déterminer de manière statique un treillis de poutres jointes. Une des méthodes les plus simples pour analyser ce genre de problème est de déterminer ses forces externes (dont les réactions) en considérant tout le treillis comme un corps libre, ensuite, depuis l'équilibre des poutres, les actions des membres sont déterminées. Généralement, le couplage d'équations en simultané est assez lent, il est habituellement possible de résoudre les actions des membres en ne considérant que les poutres qui ne subissent que deux forces membre inconnues. Comme il y a deux équations d'équilibre à chaque jonction, les équations sont souvent résolues à la main. Il y a cependant des treillis avec des configurations particulières qui rendent une telle résolution impossible. On les appelle des treillis complexes. On se limite aux treillis déterminés de manière statique, ce qui, par définition, signifie qu'ils peuvent être analysés de manière statique. En principe, pour de telles structures, on peut toujours écrire des équations pour toutes les poutres de la structure ; ainsi, si le nombre de poutres est , le nombre de membres et le nombre de réactions , pour que la structure soit soluble de manière statique, on doit avoir . Cependant, c'est une condition nécessaire mais pas suffisante, puisqu'il est possible qu'une structure soit un mécanisme, incapable de supporter la moindre charge externe, et qu'elle satisfasse cette équation. En analyse numérique, on collecte toutes les équations d'équilibre des poutres individuelles dans une structure, une matrice de connexion.

Tandis qu'il est facile pour un œil expérimenté de reconnaître des mécanismes, un critère strict plus objectif pour l'instabilité est que la matrice de connexion soit singulière (de déterminant nul). Quelques investigations intéressantes sur ce comportement sont possibles avec ce programme.

Ce programme calcule le numéro de condition de la matrice de connexion. Cela sort de loin du cadre de cet exercice, particulièrement au sujet de l'existence de multiples numéros pour une même matrice, en fonction de la norme utilisée pour dériver ce numéro. Un lecteur intéressé pourra se référer à des textes sur l'algèbre linéaire pour un traitement plus complet de ce sujet fascinant. Il suffit ici de noter que, la matrice approchant de la singularité, le numéro de condition devient plus grand. L'inverse de la matrice de connexion et le numéro de condition sont calculés par le module d'algèbre linéaire de numpy.

Regardons quelques parties de la GUI.

def qprintline(self, line):
    self.plainTextEdit_2.appendPlainText(line.rstrip())

Cette méthode ajoute une ligne à la page de solution (la sortie) et est passée au module ncrunch, ainsi il peut afficher directement les résultats dans la GUI.

Regardons la partie de la GUI qui passe toutes les données au module ncrunch et la méthode qprintline() :

def trussSolve(self):
    printline = self.qprintline
    self.plainTextEdit_2.clear()
    printline('================================') 
    flbase = os.path.basename(self.filename)
    printline('SOLUTION FOR ' + flbase)
    printline('================================') 
    dataBall = self.plainTextEdit.toPlainText()
    ncrunch.main(printline, self.filename, dataBall)

Il est à noter qu'un alias printline est créé pour la méthode qprintline. dataBall prend toutes les données de la page d'entrée (données). La page de solution est alors effacée et un en-tête est affiché. On documente le problème pour éviter la confusion entre la solution pour A et celle pour B : on doit alors afficher cet en-tête.

Il est raisonnable de vouloir séparer la partie GUI et la partie de traitement. Il a déjà été dit que la partie de traitement peut être lancée de manière séparée de la GUI. On le fait grâce à ce petit bout de code :

if __name__ == '__main__':
     
    def printline(line):
        print line

Cette fonction s'assure que printline(line) affiche son texte sur la console plutôt que dans un onglet de la GUI. Le reste du code est un programme CLI normal. Quand ncrunch est utilisé comme module, la condition ci-dessus n'est pas exécutée. À l'inverse, lors d'un lancement en ligne de commande, ncrunch.py est utilisé directement, truss.py est ignoré. Ainsi, pendant le développement, le programmeur gère les deux aspects (GUI et traitement) séparément, ce qui lui simplifie le travail fortement.

Le reste du code suit :

print 'Usage: Give a name for data in the "dat" subdirectory'
print 'as program parameter. Default is "sdtruss1.dat"'
if len(sys.argv) > 1:
    name = sys.argv[1]
else:
    name = 'sdtruss1.dat'
try:
    finput = open('dat/' + name, 'r')
    dataBall = finput.read()
    finput.close()
except IOError:
    print 'Failed to open given file name.'
    sys.exit(1)
main(printline, name, dataBall)

Une question raisonnable à laquelle une réponse doit être apportée : serait-il plus simple d'afficher toute la sortie en une seule opération ? La réponse est un très emphatique non. Quand la préparation des données est plus qu'une tâche triviale, on doit s'attendre à des erreurs. Afficher la sortie quand elle devient disponible aide à découvrir ces erreurs tôt dans le processus de préparation et simplifie l'élimination des erreurs.

Finalement, on peut espérer que vous lancerez cette analyse avec vos propres données. Il est recommandé d'utiliser un exemple existant comme gabarit et d'y substituer vos données. Comme les réactions sont remplacées par des membres auxiliaires, s'assurer que tous ces membres démarrent avec la structure plutôt qu'avec le support. Aussi, numéroter d'abord le nœud sur la structure, pour que les numéros des nœuds sur la structure soient consécutifs et le nœud éloigné de tout membre auxiliaire soit ignoré en ce qui concerne les équations d'équilibre.

Merci à Claude Leloup pour sa relecture, autant courageuse qu'attentive !