Issuu

TENSÉGRITÉ

Design, calcul et optimisation sur base d’une approche paramétrique

Flamant Alexandre Année académique : 2019-2020 Promoteur : Pierre Latteur Assesseur : Jonas Feron Lecteur : David Vanderburgh

Tenségrité : design, calcul et optimisation sur base d’une approche paramétrique Flamant Alexandre

Remerciements Ce travail de fin d'étude est le fruit d’une année de travail. Cependant, il ne s’agit pas d’un travail individuel. Bon nombre de personnes m’ont aidé à explorer et m’approprier ce sujet. Ce mémoire est également le leur. Je tiens tout d’abord à remercier Pierre Latteur ainsi que Jonas Feron pour la bienveillance dont ils ont fait preuve, mais également leurs nombreux retours constructifs qui m’ont permis de comprendre et d’approfondir ce sujet. J’aimerais également remercier Alexy Bastien, Quentin Gravy, Marc Eliears, Jonas Feron, Lindy Boucher et Igor Bouckaert pour tout le travail qu’ils ont accompli et qui m’a permis de découvrir un sujet qui m’était jusqu’à lors inconnu : la tenségrité. Je souhaite également exprimer ma reconnaissance à toutes ces personnes inconnues qui m’ont, à d’innombrables reprises, aidé à améliorer le programme issu de ce mémoire. Tout particulièrement les membres des forums dédiés à Rhinoceros et Grasshopper qui grâce à leur passion et leur altruisme m’ont sorti de bien des situations délicates. Ce mémoire n’est pas seulement une aventure académique et intellectuelle. Il s’agit également d’une aventure humaine. A ma famille, mes amis, merci pour votre soutien, votre aide et tous les merveilleux moments que nous avons vécu durant ces cinq années d’études. En particulier, je remercie mes parents, Caroline et Philippe, pour leur soutien infaillible durant cette année. Ils ont su me motiver lors des pires moments et m’accompagner lors des meilleurs. Je souhaite également remercier ma grand-mère Paule ainsi que ma tante Béatrice qui par leurs corrections et leurs commentaires éclairés m’ont permis de venir à bout de ce mémoire et, sans conteste, d’en améliorer la qualité finale. Enfin, je tiens à remercier Kachia qui m’accompagne depuis plus de cinq années et a su m’apaiser, me motiver et me pousser à donner le meilleur de moi-même. Je souhaite également la remercier pour toutes ses remarques et le temps qu’elle a investi pour moi alors même qu’elle n’en avait que bien peu pour elle. Merci à tous.

Table des matières Introduction............................................................................................................................................. 1 1.

La tenségrité ............................................................................................................................ 4 1.1.

Les origines de la tenségrité ............................................................................................ 4

1.2.

Définition ......................................................................................................................... 6

1.3.

Typologies ........................................................................................................................ 7

1.3.1.

Cellule prismatique ...................................................................................................... 7

1.3.2.

Assemblages de cellules prismatiques ...................................................................... 13

1.3.3.

Réalisations................................................................................................................ 16

Paramétrisation de la géométrie........................................................................................... 20 2.1.

Introduction ................................................................................................................... 20

2.2.

Grasshopper .................................................................................................................. 22

2.2.1.

Introduction ............................................................................................................... 22

2.2.2.

Fonctionnement ........................................................................................................ 23

2.2.3.

Types de données ...................................................................................................... 24

2.2.4.

Structures de donnée ................................................................................................ 26

2.2.5.

Plugins ....................................................................................................................... 29

2.3.

Scripts ............................................................................................................................ 33

2.3.1.

Assemblage unidimensionnel rectiligne .................................................................... 33

2.3.2.

Assemblage unidimensionnel le long d’une courbe.................................................. 40

2.3.3.

Assemblage bidimensionnel plan .............................................................................. 43

2.3.4.

Assemblage bidimensionnel non-plan ...................................................................... 47

2.3.5.

Anneau ...................................................................................................................... 50

2.3.6.

Boite .......................................................................................................................... 54

2.3.7.

Algorithme Tachi ....................................................................................................... 59

Plugin Grasshopper ............................................................................................................... 61 3.1.

Contexte ........................................................................................................................ 61

3.2.

Problématiques ............................................................................................................. 61

3.3.

Calcul scientifique au sein de Grasshopper ................................................................... 63

3.3.1.

GH_CPython .............................................................................................................. 63

3.3.2.

GH Python Remote .................................................................................................... 64

3.3.3.

COMPAS..................................................................................................................... 65

3.3.4.

Mix C#/Python ........................................................................................................... 67

3.4.

Conception du programme ........................................................................................... 67

3.4.1.

Architecture du programme ...................................................................................... 67

3.4.2.

Programmation orientée objet ................................................................................. 68 i

3.5.

Composants ................................................................................................................... 69

3.5.1.

Géométrie.................................................................................................................. 69

3.5.2.

Modélisation.............................................................................................................. 70

3.5.3.

Charges ...................................................................................................................... 74

3.5.4.

Analyse ...................................................................................................................... 76

3.5.5.

Optimisation .............................................................................................................. 78

3.5.6.

Résultats .................................................................................................................... 81

3.5.7.

Affichage .................................................................................................................... 81

3.5.8.

Outils ......................................................................................................................... 85

3.5.9.

Paramètres ................................................................................................................ 87

Calcul des structures de tenségrité ....................................................................................... 88 4.1.

Non-linéarité des structures de tenségrité ................................................................... 88

4.1.1.

Non-linéarité.............................................................................................................. 88

4.1.2.

Cas des structures de tenségrité ............................................................................... 90

4.2.

Méthode linéaire d’éléments finis ................................................................................ 91

4.2.1.

Principe ...................................................................................................................... 91

4.2.2.

Matrices de raideurs locales des éléments ............................................................... 91

4.2.3.

Matrice de raideur globale ........................................................................................ 93

4.2.4.

Conditions aux appuis ............................................................................................... 94

4.2.5.

Résolution du système d’équations .......................................................................... 95

4.2.6.

Post-traitement des résultats .................................................................................... 95

4.2.7.

Conclusion ................................................................................................................. 95

4.3.

Méthode non-linéaire ................................................................................................... 96

4.3.1.

Principe ...................................................................................................................... 96

4.3.2.

Matrice de raideur ..................................................................................................... 97

4.3.3.

Avancement dans la solution .................................................................................... 98

4.3.4.

Equation de contrainte 𝚫𝚫𝝀𝝀 ........................................................................................ 99

4.3.5. 5.

Solveur non-linéaire .................................................................................................. 99

Optimisation ........................................................................................................................ 102 5.1.

Théorie des indicateurs morphologiques .................................................................... 102

5.1.1.

Structures linéaires .................................................................................................. 102

5.1.2.

Structures non-linéaires .......................................................................................... 104

5.1.3.

Conclusion ............................................................................................................... 107

5.2.

Optimisation de la précontrainte ................................................................................ 107

5.2.1.

Application de la précontrainte ............................................................................... 108

5.2.2.

Mode d’application de la précontrainte ................................................................. 110

5.2.3.

Algorithmes d’optimisation de la précontrainte ..................................................... 112

5.3.

Optimisation des sections ........................................................................................... 114 ii

5.4. 6.

Optimisation des structures ........................................................................................ 115 Exemple d’utilisation du programme .................................................................................. 118

6.1.

Modélisation de la structure ....................................................................................... 118

6.2.

Modélisation des charges ............................................................................................ 121

6.3.

Calcul et comportement .............................................................................................. 123

6.4.

Optimisation ................................................................................................................ 125

6.5.

Variations..................................................................................................................... 126 Conclusion et perspectives .................................................................................................. 128

Table des illustrations.......................................................................................................................... 129 Références ........................................................................................................................................... 136 Annexe A.

Installation de Python et COMPAS ................................................................................... I

Annexe B.

Installation du plugin ....................................................................................................... II

Annexe C.

Validation des outils de calcul ........................................................................................ III

Annexe D.

Généralisation de la formulation de l’angle de rotation relative optimal pour une cellule prismatique .................................................................................................................. VIII

Annexe E.

Formulation des dimensions dans Grasshopper ............................................................. X

iii

Table des symboles Symbole

Unité

𝛼𝛼

[°]

[𝑚𝑚]

Flèche maximale au 𝑘𝑘 eme ordre

[−]

Variation de longueur

[ −]

Conditions aux extrémités d’un élément

[𝑚𝑚]

Flèche maximale d’une structure

[ −]

Indicateur de déplacement

𝜀𝜀

[ −]

𝜆𝜆

𝜇𝜇

[𝑁𝑁𝑁𝑁]

Paramètre d’incrémentation adimensionnel

Energie potentielle totale de la structure

𝜌𝜌

[𝑁𝑁⁄𝑚𝑚3 ]

[ −]

Indicateur de poids propre

[𝑚𝑚2 ]

Aire de la section

[𝑃𝑃𝑃𝑃]

Module de Young du matériau

[𝑁𝑁]

Composantes de la force appliquée sur un nœud

𝜎𝜎

𝐹𝐹𝑥𝑥

Angle de rotation relative entre les bases d’un simplex

𝛿𝛿

𝛿𝛿𝑘𝑘

𝑐𝑐𝑥𝑥

Signification

𝐴𝐴

𝑐𝑐𝑦𝑦 𝐸𝐸 𝐹𝐹

𝐹𝐹𝑦𝑦 𝑓𝑓𝑦𝑦 𝐻𝐻

𝑐𝑐𝑧𝑧

𝐹𝐹𝑧𝑧

Poids volumique du matériau

[𝑃𝑃𝑃𝑃]

Contrainte de dimensionnement du matériau

[ −]

Indicateur de flambement

[ −]

[𝑁𝑁]

[𝑃𝑃𝑃𝑃]

Cosinus directeurs

Charge externe totale appliquée sur la structure

Limite d’élasticité

[𝑚𝑚]

Hauteur de l’ouvrage

[𝑚𝑚]

Portée d’une structure

𝐼𝐼

[𝑚𝑚4 ]

Inertie des sections

𝐿𝐿0

[𝑚𝑚]

Longueur initiale d’un élément

𝑙𝑙𝑏𝑏

[𝑚𝑚]

Longueur des butons

𝑙𝑙𝑘𝑘

[𝑚𝑚]

Longueur d’un élément au 𝑘𝑘 eme ordre

𝐿𝐿

Δ𝐿𝐿 𝑙𝑙𝑐𝑐

𝑛𝑛𝑘𝑘

[𝑚𝑚]

Différence de longueur d’un élément

[𝑚𝑚]

Longueur des câbles

[𝑁𝑁]

Effort interne dans la structure dû à la force unitaire au 𝑘𝑘 eme ordre iv

𝑁𝑁𝑘𝑘

[𝑁𝑁]

Effort interne dans la structure au 𝑘𝑘 eme ordre

𝑞𝑞

[−]

Facteur de forme

𝑈𝑈

[𝑁𝑁𝑁𝑁]

Energie élastique interne de la structure

[𝑚𝑚3 ]

Volume total de la structure

[𝑁𝑁]

𝑃𝑃

[ −]

𝑟𝑟

𝑢𝑢𝑥𝑥

𝑢𝑢𝑦𝑦 𝑉𝑉

𝑊𝑊

𝑢𝑢𝑧𝑧

[𝑚𝑚] [ −]

Intensité de la précontrainte

Rapport des longueurs des câbles et des barres

Composantes du déplacement d’un nœud

Indicateur de volume de la structure Travail exercé par les forces externes sur la structure

𝑊𝑊𝑒𝑒𝑒𝑒𝑒𝑒

[𝑁𝑁𝑁𝑁]

� 𝐷𝐷

[𝑚𝑚]

Vecteur des déplacements imposés

𝐹𝐹�𝑖𝑖𝑖𝑖𝑖𝑖

[𝑁𝑁]

Vecteur des forces internes dans un élément

[𝑁𝑁]

Vecteur des forces externes appliquée sur une structure à l’itération 𝑘𝑘

𝑐𝑐̅

𝐹𝐹�𝑒𝑒𝑒𝑒𝑒𝑒 𝐹𝐹�𝑘𝑘

[ −]

Matrice des degrés de libertés bloqués par les conditions aux appuis

Vecteur des forces externes appliquées sur un élément

�0 𝐾𝐾

[𝑁𝑁⁄𝑚𝑚]

Matrice de raideur globale initiale d’une structure

�0,𝑙𝑙𝑙𝑙𝑙𝑙 𝐾𝐾

[𝑁𝑁⁄𝑚𝑚]

Matrice de raideur locale initiale d’un élément

�𝑘𝑘 𝐾𝐾

�𝑘𝑘,𝑙𝑙𝑙𝑙𝑙𝑙 𝐾𝐾

[𝑁𝑁⁄𝑚𝑚]

Matrice de raideur globale initiale d’une structure à l’itération 𝑘𝑘

[𝑁𝑁⁄𝑚𝑚]

Matrice de raideur locale initiale d’un élément à l’itération 𝑘𝑘

�𝑒𝑒𝑒𝑒 𝐾𝐾

[𝑁𝑁⁄𝑚𝑚]

�𝑘𝑘 𝑁𝑁

[𝑁𝑁]

Vecteur des forces internes dans une structure à l’itération 𝑘𝑘

[ −]

Etat de précontrainte

�𝐺𝐺 𝐾𝐾 𝑝𝑝̅

𝑝𝑝̅𝑠𝑠𝑠𝑠𝑠𝑠𝑠𝑠𝑠𝑠 𝑃𝑃�𝑖𝑖

[𝑁𝑁⁄𝑚𝑚] [ −]

[𝑁𝑁]

Terme élastique de la matrice de raideur

Terme géométrique de la matrice de raideur

Chargement incrémental

Scénario de précontrainte

𝑟𝑟̅

[𝑁𝑁]

Vecteur des réactions d’appuis d’une structure

𝑢𝑢�

Vecteur des déplacements des nœuds d’une structure

𝑇𝑇�𝑖𝑖,𝑗𝑗

[ −]

Matrice de changement de base

𝑢𝑢�𝑙𝑙𝑙𝑙𝑙𝑙

[𝑚𝑚]

Vecteur de déplacement des nœuds d’un élément

𝑣𝑣̅

[𝑚𝑚]

Vecteur des déplacements des nœuds à l’itération 𝑘𝑘 Vélocité incrémentale

𝑢𝑢�𝑘𝑘

Introduction La tenségrité est un concept désormais âgé de plus d’un demi-siècle. L’aspect visuel des assemblages de tenségrité renvoie une impression de légèreté et laisse une image presque onirique d’un objet pourtant bien réel. Ces caractéristiques pratiquement intrinsèques à la tenségrité n’ont depuis cessé de nourrir l’imagination de certains architectes, artistes et ingénieurs en abordant des thèmes tels que la légèreté, le vide ou encore la lumière. Malheureusement, ce terme n’évoque que bien peu de choses, si ce n’est rien du tout, à la majorité des personnes. L’année 2020 a néanmoins mis en lumière la tenségrité sur les différents réseaux sociaux la dévoilant ainsi au grand public et suscitant une émulation autour de ce concept. Malgré l’engouement de certains groupes de personnes autour de la tenségrité, celle-ci ne trouve que peu d’applications pratiques. Or, il semble commun que ces systèmes soient vus par certains comme une révolution dans le monde du génie civil. La tenségrité est même qualifiée de système structural pour le futur par René Motro [1]. Ce constat est le point de départ d’une réflexion autour de la faisabilité et des problématiques liées aux structures de tenségrité. Cette réflexion prend la forme d’une série de six mémoires, celui-ci étant le dernier L’aventure débute durant l’année académique 2013-2014 avec le mémoire d’Alexy Bastien et Quentin Gravy « Étude d’une passerelle de tenségrité composée de simplex ». Lors de celui-ci, ils se sont intéressés à diverses typologies de tenségrité afin d’imaginer une passerelle. Une typologie en particulier attire leur attention grâce à sa simplicité et son esthétique : la cellule prismatique, et plus spécifiquement le simplex. Les cellules prismatiques offrent la possibilité d’être assemblées afin de créer une structure permettant le passage de piéton. Cependant, lors de l'étude de cette structure, ils ont remarqué une caractéristique inhérente aux structures de tenségrité. Celles-ci sont instables au premier ordre. Elles ne peuvent donc pas être calculées au moyen de méthodes classiques. Ils développent néanmoins une méthode de calcul alternative permettant d’approximer le comportement des structures. Toutefois, leurs résultats peuvent être remis en cause. Durant l’année académique 2014-2015, Marc Eliaers s’attèle aux questions de calculs des structures dans son mémoire « Calcul non-linéaire des structures de tenségrité ». Il développe alors un programme MATLAB permettant l’analyse de structures instables au premier ordre grâce à une méthode d’éléments finis non-linéaire. Lors de l’année académique 2015-2016, Jonas Feron reprend le programme et développe à partir de celui-ci un programme plus complet en Python. Cet outil permet désormais de calculer des structures de tenségrité au moyen d’une méthode d’éléments finis non-linéaires ainsi que de les optimiser. Les méthodes d’optimisations utilisent notamment la théorie des indicateurs morphologiques développée par Pierre Latteur durant sa thèse doctorale. Jonas Feron étendra cette théorie aux structures tridimensionnelles, non-linéaires et précontraintes. À l’issue de son mémoire, il prouve la faisabilité de la passerelle imaginée deux ans auparavant pour une charge uniformément répartie le long du tablier. Au cours de l’année académique 2016-2017, Lindy Boucher écrit son mémoire « Optimisation des structures de tenségrité composées de modules prismatiques ». Dans le cadre de celui-ci, il étend les fonctionnalités du programme afin de prendre en compte le poids propre dans les opérations 1

d’optimisation. Il explore ensuite le champ des possibles en étudiant d’autres typologies et d’autres cellules prismatiques que le simplex. Son analyse comparative des différentes typologies permet d’affirmer que le choix initial d’utiliser des simplex est le plus efficace. Cette efficacité provient notamment du volume de matière amoindri du simplex en comparaison des autres modules. Il met cependant en évidence que d’autres typologies sont faisables et présentent leurs propres avantages. Ce faisant, il permet d’entrevoir de nombreuses possibilités de géométries. Le cinquième mémoire « Optimisation d’une passerelle de tenségrité soumise à des charges aléatoires » est réalisé durant l’année académique 2018-2019 par Igor Bouckaert. Celui-ci aborde la question de l’optimisation des structures de tenségrité afin de poursuivre le travail de Jonas Feron et prouver la faisabilité de ces structures, peu importe le cas de charge envisagé. Dans le cadre de son mémoire, il développe des outils d’optimisations supplémentaires. Ceux-ci permettent d’optimiser une structure pour des charges correspondantes aux cas les plus défavorables. Ces nouveaux outils permettent également d’obtenir bien plus rapidement une bonne approximation du comportement des structures. Enfin, il démontre la faisabilité des passerelles et que, dans la plupart des cas, le critère dimensionnant n’est pas celui des déformations, le dimensionnement aux états limites de service, mais bien le calcul de résistance, le dimensionnement aux états limites ultimes. Ce mémoire est donc le sixième abordant le thème de la tenségrité et a pour but d’étendre la portée des précédents mémoires afin de pouvoir étudier un vaste éventail de typologie de structures de tenségrité. Mon objectif est d’aborder la question de la tenségrité sous une approche paramétrique au moyen du logiciel Grasshopper. Dans le cadre de cette étude, je synthétiserai les travaux précédents afin de créer un programme s’intégrant à Grasshopper. Ce programme, prenant la forme d’un plugin, propose des outils permettant d’étendre les réalisations des mémoires précédents à n’importe quelle structure de tenségrité. Au terme de ce mémoire, un nouveau programme sera développé et intégré au logiciel Grasshopper. Ce programme permettra de créer des géométries jusqu’à lors non abordées, mais également démultiplier les paramètres permettant de créer les géométries des structures étudiées précédemment. Le programme contiendra également un ensemble d’outils permettant le calcul et l’optimisation de ces mêmes structures au sein même de Grasshopper offrant ainsi une plus grande interactivité dans le design de ces structures. Ce mémoire se divise en six chapitres : Le chapitre 1 a pour objectif d’établir une définition de la tenségrité et d’en présenter l’histoire jusqu’à ce jour tant dans le domaine de la construction que celui de l’art. Ce chapitre aborde également les principales typologies applicables à la structure tant du point de vue des techniques d’assemblage que des caractéristiques. Le chapitre 2 présentera le logiciel Grasshopper et décrira les tenants et aboutissants d’une approche paramétrique. Ensuite, ce chapitre présentera les méthodes utilisées pour créer des géométries de tenségrité ainsi que la multitude de paramètres définissant une structure de tenségrité. Le chapitre 3 montre le développement du programme ainsi que les diverses contraintes liées à celui-ci. Après description du contexte de développement du programme, celui-ci sera présenté en détail. Le chapitre 4 synthétise les méthodes de calcul non-linéaires développées lors des précédents mémoires permettant ainsi d’analyser des structures dans Grasshopper. 2

Le chapitre 5 présente les méthodes d’optimisation des structures de tenségrité développées lors des mémoires précédents et ayant été mises en œuvre dans le programme. Le chapitre 6 illustre le fonctionnement du logiciel au moyen d’un exemple de structure.

1. La tenségrité Ce chapitre a pour but d’offrir une introduction à la tenségrité. Cette introduction débute par une description de ses origines ainsi que de l’évolution du concept à travers les décennies. Ensuite, il propose une définition formelle de celle-ci pour en dégager l’essence de ce qu’est une structure de tenségrité. Cette définition est également discutée afin de suggérer une définition élargie. Plus tard, il s’attarde sur les différentes typologies de structures de tenségrité illustrée dans la littérature. Plus spécifiquement, le cas des cellules prismatiques sera introduit afin de découvrir les premières caractéristiques inhérentes aux structures de tenségrité Enfin, le chapitre propose un tour d’horizon des réalisations s’apparentant à la tenségrité tant dans le domaine du génie civil que le monde artistique.

1.1. Les origines de la tenségrité Le terme tenségrité vient de l’anglais tensegrity qui est lui-même issu de la contraction de tensional integrity exprimant le fait que la stabilité du système provient des éléments en tension. Ce terme fut proposé par l’architecte américain Richard Buckminster Fuller actif dans les années 1950. [2]

Figure 1-1 Richard Buckminster Fuller, inventeur de la tenségrité [3]

Bien que celui-ci l’ait nommé, on retrouve dès 1920 des sculptures de l’artiste constructiviste russe Karl Johansson qui témoignent des origines de la tenségrité. On observe dans son exposition Spatial constructions de 1921 et plus particulièrement dans son œuvre study in balance, 30 ans avant que ce concept ne trouve son appellation, les grandes idées des structures de tenségrité. Avec cette œuvre, Karl Johansson ne cherche pas à rendre sa sculpture stable. En laissant un câble relâché il permet à l’ensemble de se déformer à loisir. Il cherche à montrer la façon dont les structures tendues peuvent se déformer. Cette liberté de mouvement empêche de qualifier cette œuvre de tenségrité. Néanmoins, on retrouve des caractéristiques propres à la tenségrité. Si bien que l’on pourrait être tenté de qualifier « Study in balance » de proto-tenségrité. 4

Figure 1-2 Study in balance [4]

L’origine des premiers assemblages de tenségrité à proprement parler semble toutefois revenir à Richard Buckminster Fuller qui obtint les premiers brevets. Cette origine est toutefois contestée. Il semblerait que l’idée initiale pourrait venir d’un de ses étudiants Kenneth Snelson. Celui-ci aurait présenté à son professeur une série de sculptures, dont une sculpture novatrice semblant flotter dans les airs : la X-Structure.

Figure 1-3 X-Piece [5]

Richard Buckminster Fuller dit que celle-ci catalysa ses idées et offrit un second souffle au concept [2] tandis que Kenneth Snelson déclara que celui-ci lui vola son idée. En parallèle, l’architecte-ingénieur français David-Georges Emmerich développe et popularise des systèmes reposants sur les mêmes principes et qu’il qualifie de systèmes autotendants. Il invente de nombreuses typologies complexes qu’il ne mettra jamais en pratique. Son travail reste ainsi purement théorique.

Figure 1-4 Tore hélicoïdal [6]

1.2. Définition La première définition de la tenségrité provient de Richard Buckminster Fuller. Celui-ci la définit comme étant : « Islands of compression in a sea of tension ». On lui préférera toutefois la définition de René Motro [1]: « Les systèmes de tenségrité sont des systèmes réticulés spatiaux en état d’autocontrainte. Tous leurs éléments ont une fibre moyenne rectiligne et sont de taille équivalente. Les éléments tendus n’ont pas de rigidité en compression et constituent un réseau continu. Les éléments comprimés n’ont pas de rigidité en traction et constituent un ensemble discontinu. Chaque nœud reçoit un et un seul élément comprimé et au moins trois câbles. » Cette définition, plus précise que celle de Richard Buckminster Fuller propose plusieurs indications concernant la nature structurale des systèmes de tenségrité : - « Les systèmes de tenségrité sont des systèmes réticulés spatiaux […] » : les structures de tenségrité sont des systèmes constitués d’un réseau continu de câbles et de barres. - « […] en état d’autocontrainte. » : les structures, sans chargement externe, possèdent des efforts internes non nuls. Sans cet état de contrainte, les structures ne possèdent aucune rigidité. - « Tous leurs éléments ont une fibre moyenne rectiligne et sont de taille équivalente. » : ce point est sujet à controverse. Il est implicitement issu des premiers brevets du concept de tenségrité. - « Les éléments tendus n’ont pas de rigidité en compression et constituent un réseau continu. » : Les éléments tendus sont de type câbles et ne présentent aucune rigidité en compression. Ils doivent ainsi être tendus en toutes circonstances. Ces mêmes éléments forment un ensemble continu créant ainsi l’enveloppe externe de la structure. - « Les éléments comprimés n’ont pas de rigidité en traction et constituent un ensemble discontinu. » : Les éléments comprimés sont des butons 1 et doivent être comprimés en toutes circonstances. Ces éléments comprimés sont discontinus et ne peuvent donc être en contact les uns des autres. René Motro dans sa définition étendue apporte une précision concertant le fait que ces éléments comprimés sont compris au sein de l’enveloppe que forme l’ensemble des éléments tendus. - « Chaque nœud reçoit un et un seul élément comprimé et au moins trois câbles. » : Ce point est également présent dans les brevets initiaux. Toutefois, ce point provoque également débat, car il existe des systèmes stables où certains nœuds ne reçoivent pas d’éléments comprimés. Afin de faciliter la lecture, le mot « barre » sera employé, sauf mention contraire, pour qualifier les butons pour le reste du mémoire. Le terme « barre » est bien mieux intégré à la vie quotidienne que « buton » et rend la lecture plus fluide. Il est important de noter que la définition de René Motro est restrictive. Il existe de nombreux systèmes structuraux ne correspondant pas à la définition proposée par celui-ci, mais dont la stabilité est apportée par les éléments en tension. Il existe en effet des configurations stables au sein desquelles les barres sont non rectilignes ou sur l’enveloppe extérieure. On retrouve également des structures où des nœuds reçoivent plus de trois câbles ou encore plusieurs barres. 1

Un buton est un élément comprimé d’une structure du génie civil.

Figure 1-5 Cellule octaédrique présentant des barres dans son enveloppe [illustration de l’auteur]

Figure 1-6 Assemblage dont plusieurs barres se touchent [illustration de l’auteur]

La figure 1-5 et la figure 1-6 présentent deux assemblages qui, si l’ont ne se fie pas à la définition, semble être de la tenségrité. Dans le premier cas, les barres sur l’enveloppe excluent la cellule octaédrique de la définition de la tenségrité. Dans le second cas, ce sont les barres se rejoignant en un seul nœud qui provoque cette exclusion. Cependant, dans les deux cas, l’intégrité de la structure repose bien sur les câbles. Conscient des limites de sa définition, René Motro [1] propose une définition étendue : « Un système de tenségrité est un système stable en état d’autoéquilibre comprenant un ensemble discontinu d’éléments comprimés compris au sein de continuum d’éléments tendus » Cette définition, moins restrictive que la précédente, permet un éventail plus large de configurations offrant ainsi une plus grande liberté de création. Cette définition sera donc utilisée dans le cadre de ce mémoire. Deux hypothèses seront également considérées vis-à-vis de l’analyse des structures : - Les nœuds sont considérés comme étant parfaitement rotulés. - Les charges externes sont appliquées au niveau des nœuds. Ces caractéristiques sont en fait celles d’un treillis. Les structures de tenségrité seront en effet analysées comme des treillis. Néanmoins, là ou le treillis est composé d’éléments pouvant fonctionner tant en compression qu’en traction, les structures de tenségrité sont composées de câbles ne pouvant subir de la compression. Il sera donc essentiel lors de l’analyse de s’assurer que les câbles sont bien tendus.

1.3. Typologies Il existe de nombreux critères permettant de définir une typologie de structure de tenségrité. Chacun de ses critères permet d’obtenir une nouvelle géométrie. Il existe donc une infinité de structures possibles. Celles-ci peuvent soit être un assemblage unique soit être décomposées d’une série de modules simples étant chacun en état d’autoéquilibre.

1.3.1. Cellule prismatique De tous les modules de tenségrité existants, une des typologies les plus simples est la cellule prismatique. Il s’agit d’un assemblage de tenségrité composé de deux bases polygonales. Chaque cellule prismatique possède un angle de rotation relatif entre les deux bases qui lui est spécifique. La figure 1-7 montre un exemple de cellule prismatique.

1.3.1.1. Simplex régulier Le simplex est la plus simple de toutes les cellules prismatiques. Elle est composée de 3 barres, en rouge, et 9 câbles. Parmi ces 9 câbles, 6 constituent les deux bases triangulaires, en bleu, tandis que les 3 câbles restants, en vert, relient les deux bases.

Figure 1-7 Simplex [illustration de l'auteur]

La figure 1-8 présente un schéma d’assemblage de simplex. Une fois ce schéma réalisé, il suffit de relier les extrémités des éléments verts afin de former une boucle supérieure et une boucle inférieure et de relier la flèche bleu à l’élément rouge de l’autre coté de l’assemblage

Schéma 2D

Fermeture du schéma

Figure 1-8 Schéma de fabrication d'un simplex régulier [illustration de l'auteur]

L’angle de rotation 𝛼𝛼 est directement lié à la géométrie ainsi qu’à la stabilité de la structure. Il existe une relation liant l’angle de rotation 𝛼𝛼, la longueur des câbles 𝑙𝑙𝑐𝑐 et la longueur des barres 𝑙𝑙𝑏𝑏 . Prenons le cas d’un simplex régulier [7], un simplex dont tous les câbles ont la même longueur permettant ainsi de simplifier le problème - le rapport entre 𝑙𝑙𝑏𝑏 et 𝑙𝑙𝑐𝑐 est le suivant :

𝑟𝑟 ≜

Figure 1-9 Vue d'une face d'un simplex régulier

2 𝑙𝑙𝑏𝑏 = �1 + sin(𝛼𝛼 + 60°) 𝑙𝑙𝑐𝑐 √3

Cette relation prend la forme suivante : Vue 3D

𝛼𝛼

Vue en plan

𝛼𝛼 = 60°

𝛼𝛼 = 30°

𝛼𝛼 = 0° Figure 1-10 Variation de l'angle de rotation d'un simplex régulier [illustration de l’auteur inspirée de [8]]

Plusieurs caractéristiques importantes : - Si la longueur des câbles est trop grande, on obtient 𝑟𝑟 < √2 . La géométrie n’est pas définie. Les barres peuvent se déplacer librement. - Le rapport 𝑟𝑟 = √2 est obtenu pour deux angles : 𝛼𝛼 = 0° et 𝛼𝛼 = 60°. Dans ce dernier cas, comme on peut l’observer dans la Figure 1-10, les barres se rejoignent en un seul point. - Le rapport 𝑟𝑟 = 1,468 correspond à un angle 𝛼𝛼 = 30°. Il n’existe qu’une configuration possible pour cet angle. - Pour tout angle 𝛼𝛼 ≠ 30°, il existe deux géométries possibles. Il existe une instabilité intrinsèque de la géométrie des cellules de tenségrité. - Pour un angle 𝛼𝛼 = 30°, la cellule ne possède aucune rigidité. La moindre perturbation du système modifiera le rapport 𝑟𝑟 ce qui engendrera une torsion pour atteindre l’équilibre à un angle 𝛼𝛼 = 30 ± 𝜀𝜀. Le simplex est donc intrinsèquement instable en torsion. - Si la longueur des câbles n’est pas suffisante, ou celle des barres trop importante, les câbles s’allongeront par tractions et les barres se raccourciront par compression. Amenant le simplex à un rapport 𝑟𝑟 = 1,468 et donc un angle 𝛼𝛼 = 30°. La structure entre alors en état d’autocontrainte et est en équilibre stable. Les efforts internes dû à l’état d’autocontrainte offrent à la cellule une rigidité initiale.

1.3.1.2. Quadruplex régulier Le quadruplex régulier est composé de 4 barres, en rouge, et 12 câbles. Parmi ces 12 câbles, 8 constituent les deux bases carrées, en bleu, tandis que les 4 câbles restants, en vert, relient les deux bases.

Figure 1-11 - Schéma de frabrication d'un quadruplex régulier [illustration de l'auteur]

𝛼𝛼

L’étude du rapport 𝑟𝑟 pour le quadruplex régulier nous permet d’obtenir la courbe suivante. Vue 3D

Vue en plan

𝛼𝛼 = 90°

𝛼𝛼 = 45°

𝛼𝛼 = 0° Figure 1-12 Variation de l'angle de rotation d'un quadruplex régulier [illustration de l’auteur]

On observe des caractéristiques similaires à celles du simplex. On observe néanmoins un avantage majeur de cette cellule par rapport au simplex est sa géométrie qui est plus adaptée à l’utilisation. Offrant notamment, dans le cas d’une passerelle, une hauteur de passage plus importante et régulière.

1.3.1.3. Pentaplex régulier Le pentaplex régulier est composé de 5 barres, en rouge, et 15 câbles. Parmi ces 15 câbles, 10 constituent les deux bases pentagonales, en bleu, tandis que les 4 câbles restants, en vert, relient les deux bases.

Figure 1-13 Schéma de fabrication d'un pentaplex régulier [illustration de l’auteur]

𝛼𝛼

L’étude du rapport 𝑟𝑟 pour le pentaplex régulier nous permet d’obtenir la courbe suivante. Vue 3D

Vue en plan

𝛼𝛼 = 72°

𝛼𝛼 = 54°

𝛼𝛼 = 0° Figure 1-14 Variation de l'angle de rotation d'un pentaplex régulier [illustration de l’auteur]

On observe des caractéristiques similaires à celles du simplex. On remarque toutefois que tous les angles ne sont pas possibles pour un assemblage régulier. Le rapport 𝑟𝑟 = 1,618 correspond à un angle 𝛼𝛼 = 72°. Comme on peut l’observer dans la figure 1-14, Il s’agit d’une géométrie plane.

1.3.1.4. Cellules prismatiques non régulières

L’étude du pentaplex nous montre que toutes les cellules prismatiques régulières ne peuvent exister. En réalisant une étude similaire sur les cellules d’ordre supérieur, on observe que certaines cellules ne peuvent même pas atteindre leur angle de rotation stable. La méthode utilisée trouve donc sa limite.

Figure 1-15 Comparaison des rapports 𝑟𝑟 en fonction des angles de rotations pour des cellules régulières [illustration de l’auteur]

Toutefois, il s’avère que l’angle de rotation relatif optimal n’est pas fonction du rapport 𝑟𝑟. Cet angle est spécifique à la typologie de cellule prismatique.

Simplex 𝐷𝐷𝑒𝑒𝑒𝑒𝑒𝑒 = 10𝑚𝑚 𝐻𝐻 = 5𝑚𝑚

Simplex régulier 𝐷𝐷𝑒𝑒𝑒𝑒𝑒𝑒 = 10𝑚𝑚

Simplex 𝐷𝐷𝑒𝑒𝑒𝑒𝑒𝑒 = 10𝑚𝑚 𝐻𝐻 = 15𝑚𝑚

Figure 1-16 Simplex de différentes hauteurs tous stables pour [Illustration de l'auteur]

Richard William Burkhardt démontre dans Practical Guide to Tensegrity design [9] que la hauteur d’un simplex n’influence pas l’angle de rotation optimal qui reste 𝛼𝛼 = 30°. De manière plus générale, Tibert et Pellegrino [10] ont déterminé analytiquement les angles de rotation optimaux pour les cellules prismatiques. Cet angle est indépendant de la hauteur du prisme : 1 𝑗𝑗 𝛼𝛼 = 𝜋𝜋 � − � 2 𝑛𝑛

Avec 𝑛𝑛 le nombre de côtés du polygone de référence et J un entier plus petit que 𝑛𝑛

Il s’agit des angles permettant d’obtenir un autoéquilibre des forces de tractions dans les câbles et des forces de compression dans les barres. Il est intéressant de montrer que certaines cellules peuvent avoir plusieurs angles permettant un équilibre. 𝑣𝑣 3 4 5 6 7 8 9

1 30° 45° 54° 60° 64° 68° 70°

2 −30° 0° 18° 30° 39° 45° 50°

3 − −45° −18° 0° 13° 22° 30°

4 − − −54° −30° −13° 0° 10°

𝑗𝑗

5 − − − −60° −39° −22° −10°

6 − − − − −64° −45° −30°

7 − − − − − −68° −50°

8 − − − − − − −70°

Tableau 1-1 Valeur de 𝛼𝛼 pour une série de cellules prismatiques [Illustration de l'auteur adaptée de [10]]

On observe également un schéma se répétant. Les cellules prismatiques dont la base polygonale est d’ordre 2𝑛𝑛 sont à l’équilibre pour des angles leur étant propres, mais également pour les angles propres aux cellules prismatiques dont la base polygonale est d’ordre 𝑛𝑛.

On peut se convaincre par le fait que ces cellules sont une superposition de deux cellules d’ordre donc la base polygonale est d’ordre 𝑛𝑛. Chacune pouvant être à l’équilibre indépendamment de l’autre.

Cette relation reste également valable dans le cas d’un prisme dont les deux bases sont de dimensions différentes. La validité de cette relation est démontrée en Annexe D.

1.3.2. Assemblages de cellules prismatiques La stabilité, voire la faisabilité, d’une structure de tenségrité s’avère difficile à atteindre. A fortiori, plus la structure est complexe, que ce soit par le nombre d’éléments ou la géométrie, plus ardue sera la tâche. Cette complexité offre néanmoins de nombreuses opportunités autant du point de vue de l’architecture que de la structure. Une manière de dépasser cette complexité est de, comme le dit l’adage, diviser pour mieux régner. Ainsi, il est possible d’assembler différentes cellules de tenségrité en une structure plus grande. René Motro [1] décrit notamment deux types d’assemblages : - L’assemblage nœud sur nœud : assemblage où plusieurs barres se rejoignent en un même nœud. Ce type d’assemblage est repris dans la définition étendue proposée par René Motro.

Figure 1-17 Schéma de fabrication d'un assemblage nœud sur nœud de deux simplex [illustration de l'auteur]

- L’assemblage nœud sur câble : assemblage où chaque nœud ne reçoit qu’une seule barre. Ce type d’assemblage est repris dans la première définition proposée par René Motro.

Figure 1-18 Schéma de fabrication d'un assemblage nœud sur câble de deux simplex [illustration de l'auteur]

1.3.2.1. Assemblages unidimensionnels. Les assemblages unidimensionnels composés de cellules prismatiques sont définis par une direction principale caractérisant l’assemblage. La géométrie type de cette typologie se prête particulièrement bien au design de passerelle ou encore de mât comme cela a déjà pu être réalisé par Kenneth Snelson présenté en figure 1-26. Cette direction principale ne doit toutefois pas être rectiligne. Ainsi, en utilisant des courbes comme direction principale, il est possible de décupler le potentiel géométrique de ce type d’assemblage unidimensionnel comme a pu le faire David-Georges Emmerich pour son tore hélicoïdal.

Figure 1-19 Tore hélicoïdal [6]

Comme décrit précédemment, ces assemblages peuvent être créés nœud sur nœud auquel cas on retrouve un réseau d’éléments comprimés continus. Il est également possible d’utiliser une méthode nœud sur câble résultant en un assemblage au sein duquel l’ensemble des éléments comprimés sont discontinus.

Figure 1-20 Assemblage unidimensionnel nœud sur nœud [illustration de l'auteur]

Figure 1-21 Assemblage unidimensionnel nœud sur câble [illustration de l'auteur]

1.3.2.2. Assemblages bidimensionnels La principale difficulté de créer un assemblage bidimensionnel est la jonction entre les différentes cellules composant cet assemblage. De nombreuses solutions ont déjà été proposées ayant chacune leur particularité. On peut notamment citer la proposition d’Ariel Hanaor [11] suivant un mode d’assemblage nœud sur câble.

Figure 1-22 Type de jonctions [11]

Figure 1-23 Jonctions de six simplex

Une autre proposition suivant un mode d’assemblage nœud sur nœud émane de l’équipe de recherche de René Motro.

Figure 1-24 Vue axonométrique d'un assemblage bidimensionnel nœud sur nœud [1]

Une fois les cellules prismatiques mises bout à bout, grâce à une méthode de jonction, il est possible de créer une grande diversité d’assemblages allant d’une structure plane à une structure présentant de multiples courbures.

1.3.3. Réalisations La tenségrité est définie et étudiée depuis plus d’une cinquantaine d’années. Il n’est donc pas étonnant que cette typologie ait donné naissance à de nombreuses réalisations principalement dans le domaine artistique.

1.3.3.1. Art Le monde artistique est particulièrement prolifique. Il fut le premier moteur du développement de la tenségrité. S’il serait vain de vouloir définir une liste exhaustive des œuvres ayant attrait à la tenségrité ayant été réalisées durant toutes ces années, certaines réalisations sont remarquables. Parmi tous les acteurs ayant participé à l’évolution de la tenségrité, Kenneth Snelson en est sans conteste la figure de proue. Comme évoqué précédemment, celui-ci est considéré comme étant à l’origine du concept de tenségrité. Il n’est donc pas étonnant qu’il soit à l’origine de nombreuses œuvres de tenségrité. On pense notamment au X-Piece, visible à la figure 1-3, ayant servi de point de départ à la tenségrité. Toutefois, il réalisa plusieurs sculptures par la suite. Parmi celles-ci, les Needle Tower, des mâts constitués d’une structure de tenségrité, et l’Easy Landing situé à Baltimore, ont connu un succès certain grâce à leurs dimensions impressionnantes notamment celles de la Needle Tower II, située au musée Kröller-Müller, culminant à 30 mètres de haut.

Figure 1-25 Easy Landing [12]

Figure 1-26 Needle Tower II [13]

L’aspect contemplatif est celui principalement mis en avant par Kenneth Snelson. Toutefois, certains artistes mettent en œuvre la tenségrité de manière plus utilitaire. C’est notamment le cas du designer américain Robby Cuthbert dont les créations sont tant contemplatives que fonctionnelles.

Figure 1-27 Contour Coffee Table [14]

Figure 1-28 Muscle 3 [14]

1.3.3.2. Structures Bien que la tenségrité soit abondamment étudiée et décrite comme un excellent système structural. Il est étonnant que ce système décrit par René Motro comme un « système structural pour le futur » n’ait que peu, voire pas, de construction réelle dans les structures du génie civil [15]. Une de ces applications est le Kurilpa Bridge, une passerelle cycliste et piétonne traversant la rivière Brisbane à Brisbane en Australie. Celle-ci fut imaginée par le bureau d’architecture Cox Rayner Architects et vérifiée par le bureau de stabilité Ove Arup & Partners. Le Kurilpa Bridge mesure 470m de long, dont une portée principale de 128m de long. Ces dimensions en font l’ouvrage de tenségrité le plus important à ce jour. Toutefois, cette dernière affirmation reste débattue. En effet, les seuls éléments comprimés n’étant pas liés à d’autres éléments comprimés sont les barres horizontales. Le reste des éléments comprimés se rattachent au tablier fonctionnant lui-même en flexion. Ceci mène certains à être en désaccord avec la qualification de cette structure comme étant de la tenségrité.

Figure 1-29 Kurilpa Bridge [16]

D’autres projets d’architectures ont été imaginés bien que n’ayant pas été mis en œuvre. C’est notamment le cas du bureau d’architecture New-yorkais Atelier Architecture 64 ayant conçu lors d’un de leurs ateliers une passerelle de tenségrité surplombant la rivière Irwell pour le concours Salford Meadows Bridge.

Figure 1-30 Tensegrity Bridge [17]

Enfin, on retrouve d’autres projets notables n’étant pas englobés par la définition initiale de la tenségrité. C’est le cas du pavillon Ninety Nine Faillures réalisé par le Digital Fabrication Lab de l’université de Tokyo fondé par l’architecte Kengo Kuma.

Figure 1-31 Ninety Nine Failures - Vue intérieure [18]

Figure 1-32 Ninety Nine Faillures - Vue extérieure [18]

2. Paramétrisation de la géométrie Ce chapitre présente la première partie du programme traitant de la génération des géométries de tenségrité dans Grasshopper. Afin de faciliter la compréhension, le chapitre présente en premier lieu le fonctionnement de Grasshopper mais également les géométries utilisables ainsi que la façon dont les données sont structurées. Une fois cette introduction à Grasshopper réalisée, l’outil de création de géométrie sera introduit au moyen d’exemples de réalisations. Son fonctionnement global sera ensuite décrit.

2.1. Introduction Une structure, quelle qu’elle soit, est composée d’une multitude d’éléments. Modéliser chacun de ces éléments est une tâche longue et souvent complexe. Dans le cadre d’un projet d’architecture ou d’un dimensionnement, la structure peut être amenée à changer. Une seule modification peut donc signifier une nouvelle modélisation tout aussi longue et complexe. Cette méthode de création manuelle s’avère particulièrement inefficace. Il est alors intéressant de songer à créer cette géométrie selon une approche systématique. Cette démarche est qualifiée de modélisation paramétrique. Afin d’illustrer les avantages de la méthode paramétrique, prenons l’exemple d’un simplex qui créé manuellement et paramétriquement.

Figure 2-1 Simplex régulier [illustration de l'auteur]

L’encodage manuel d’un simplex se fait de la manière suivante : - Chaque point est représenté au sein d’une liste par ses coordonnées cartésiennes. - Chaque barre est représentée au sein d’une liste par son nœud de départ et son nœud de fin. # Coordonnées des points points = [[-3.9499999999999984, -6.8416006898970654, 0.0], [7.8999999999999986, 0.0, 0.0], [-3.9499999999999966, 6.8416006898970654, 0.0], [0.0, -7.8999999999999995, 13.057844037220447], [6.8416006898970645, 3.9499999999999984, 13.057844037220447], [-6.8416006898970627, 3.9500000000000028, 13.057844037220447]] # Connections des câbles cables_connections = [[3, [4, [5, [0, [1, [2, [3, [4, [5,

0], 1], 2], 1], 2], 0], 4], 5], 3]]

# Connections des barres barres_connections = [[4, 0], [5, 1], [3, 2]] Figure 2-2 Encodage d'un simplex régulier

Cet encodage correspond à un simplex précis et pourrait être une source d’erreur. En utilisant une approche paramétrique, cette tâche devient à la fois plus simple et fiable. C’est pourquoi elle a été choisie pour la modélisation. Afin d’illustrer la facilité de modélisation, imaginons un simplex. On peut en dégager trois paramètres géométriques principaux visible en figure 2-3: - 𝜃𝜃 : L’angle de rotation relative entre les bases - 𝐷𝐷 : Le diamètre extérieur de la base - 𝐻𝐻 : La hauteur de la cellule

Figure 2-3 Paramètres principaux régissant la géométrie d'un simplex [Illustration de l'auteur]

La modification de chacun de ces paramètres implique une modification conséquente de la géométrie de la structure. Un algorithme adéquat permet de recréer la géométrie au moyen de la définition de ces paramètres. C’est là toute la puissance d’une telle définition. 21

Figure 2-4 Définition paramétrique d'un simplex via le logiciel Grasshopper [illustration de l'auteur]

2.2. Grasshopper 2.2.1. Introduction De nombreux outils permettent de réaliser des définitions paramétriques. Ces outils sont principalement des langages de programmation. Dans le cas d’opérations géométriques, l’utilisation de ces outils est souvent complexe et consommatrice de ressources. Toutefois, en utilisant des outils adaptés, ces limitations peuvent être surmontées. Un de ces outils est Grasshopper, il s’agit d’une interface de programmation visuelle fonctionnant au sein du logiciel de modélisation 3D Rhinoceros. Celui-ci est bien connu dans le monde de la construction. Il est notamment utilisé dans le cadre d’analyse structurale, de la recherche de forme ou encore de l’analyse des performances environnementales des ouvrages. En outre, Grasshopper offre de nombreux bénéfices en comparaison des autres langages de programmation. Grasshopper étant spécialisé dans la génération de géométries complexes, son bénéfice premier est l’éventail d’outils proposés permettant la décomposition de définitions géométriques complexes en une série d’opérations simples. Cette décomposition est mise en évidence dans la Figure 2-4. Un autre avantage qu’offre l’interface est la capacité de visualisation offerte par l’intégration de Grasshopper au sein de Rhinoceros. Le retour visuel direct offert permet une évaluation visuelle simple réduisant ainsi la complexité de modélisation.

Figure 2-5 Visualisation du simplex dans Rhinoceros [illustration de l'auteur]

Enfin, la large communauté multidisciplinaire gravitant autour de Grasshopper offre un terreau fertile au développement de la tenségrité au cœur du monde artistique et celui de la conception structurale.

2.2.2. Fonctionnement Grasshopper possède une interface graphique d’une grande intuitivité. Le logiciel fonctionne par liaisons de différents composants disposant chacun d’un nombre défini de paramètres d’entrée, à droite, ainsi que d’un nombre défini de paramètres de sortie, à gauche.

Figure 2-6 Composant « Ellipse » [Illustration de l’auteur]

L’ensemble des informations concernant chacun des composants peut être obtenu en le survolant avec sa souris. Survoler les entrées et sorties d’un composant présentera ainsi une description de ces derniers tandis que survoler le centre d’un composant affichera des informations sur le fonctionnement de celui-ci.

Description de l’entrée R1

Description du composant

Figure 2-7 Description du composant « Ellipse » et d'un de ses paramètres d'entrée [Illustration de l’auteur]

On observe dans la description, à l’intérieur de l’encart inférieur, la valeur actuelle du paramètre. Dans ce cas de figure, rien n’est branché au composant, il s’agit de la valeur par défaut du paramètre. Tous les composants n’ont pas de valeurs prédéfinies, il est donc important de les vérifier. Tout ces composants peuvent être branchés les uns aux autres afin de créer des scripts plus complexes. Voici par exemple un script permettant de créer un prisme à partir de l’extrusion d’un polygone.

Figure 2-8 Script créant un prisme par extrusion [Illustration de l'auteur]

Ce script simple contient sept composants. Les trois premiers, à la droite du script, sont des sliders permettant de définir un nombre. Les sliders « Rayon externe » et « Segments » sont branchés dans le composant « Polygone » donc la sortie P est le polygone. Le troisième slider est branché au composant « Unit Z » et permet de multiplier un vecteur unitaire dans la direction Z. Le polygone obtenu est branché au paramètre G du composant « Move » tandis que le vecteur est branché dans l’entrée T. La sortie G est le polygone ayant subi une translation correspondant au vecteur entré en paramètre. Le polygone de départ et le polygone déplacé sont ensuite branchés au composant « Loft ». Celui-ci permet de créer une surface reliant les deux courbes. Les paramètres d’entrée n’étant pas branchés utilisent leur valeur par défaut. Ce script permet de créer une infinité de géométries en modifiant simplement les sliders.

𝑅𝑅 = 5 𝑆𝑆 = 5 𝐻𝐻 = 10

𝑅𝑅 = 5 𝑆𝑆 = 5 𝐻𝐻 = 2

𝑅𝑅 = 2,5 𝑆𝑆 = 5 𝐻𝐻 = 10

𝑅𝑅 = 5 𝑆𝑆 = 3 𝐻𝐻 = 10

Figure 2-9 Résultats de différentes configurations du script [Illustration de l'auteur]

On observe µune convention dans les scripts Grasshopper : un script progresse de gauche à droite. Bien qu’il ne soit pas exclu d’aller de gauche à droite, on aura tendance à trouver les paramètres d’un script à la droite de ce dernier et le résultat final à la gauche.

2.2.3. Types de données Les outils de générations de géométries sont basés sur des types de données. Ces types représentent notamment des objets mathématiques et géométriques. Ce sous-chapitre a pour but de présenter une liste non exhaustive des types de données utilisées dans Rhino et Grasshopper afin de permettre une bonne compréhension de ce chapitre. Ce chapitre se base notamment sur le livre électronique « The Grasshopper primer » [19] écrit par les équipes de McNeel, la société développant Rhino et Grasshopper. Ce livre offre de plus amples descriptions des types de données en général. Une autre source réservée aux utilisateurs avertis est l’API RhinoCommon [20] qui recense de manière technique l’ensemble des propriétés des données et des outils de programmation offert par McNeel.

2.2.3.1. Point Il existe deux sortes de points : - Les points 3d caractérisés par leurs coordonnées (𝑥𝑥, 𝑦𝑦, 𝑧𝑧) - Les points 2d caractérisés par leurs coordonnées (𝑥𝑥, 𝑦𝑦) ou (𝑢𝑢, 𝑣𝑣) en fonction du type de système de coordonnées en jeu

Figure 2-10 Points 3D et 2D [19]

2.2.3.2. Courbe Dans Grasshopper, les courbes sont un type général pouvant se spécifier en plusieurs types primitifs, notamment : 1. 2. 3. 4. 5.

La ligne caractérisée par ses extrémités qu’elle relie La polyligne caractérisée par une liste de points ordonnés et de lignes reliant ces derniers Le cercle caractérisé par un plan, un centre et un rayon L’ellipse caractérisée par un plan, un centre et les rayons dans les directions 𝑥𝑥 et 𝑦𝑦 L’arc de cercle caractérisé par un plan, un centre, un rayon et l’angle caractérisant la portion du cercle. 6. La NURBS spline qui est une fonction mathématique permettant de modéliser avec une grande précision toutes sortes de géométries complexes 7. La polycourbe une courbe qui peut contenir l’ensemble des autres types primitifs.

Figure 2-11 Représentation des types primitifs des courbes [19]

Il est important de noter que l’ensemble des points définissants la courbe forment une liste ordonnée. Le début et la fin d’une courbe sont bien distincts.

2.2.3.3. Surface Grasshopper permet de modéliser de nombreux types de surfaces. Hormis les types primitifs tels que : la sphère, le cylindre, le plan ou encore le cône. Il existe également d’autres types de surfaces. La surface NURBS, « Non-Uniform Rational BSpline », est l’une des plus utiles. Il s’agit d’une représentation mathématique de la surface permettant de modéliser de manière très précise des surfaces et courbes complexes. Ces surfaces sont définies par leur système de coordonnées propre (𝑢𝑢, 𝑣𝑣) permettant d’obtenir facilement les points sur la surface.

Figure 2-12 Comparaison de l'évaluation d’un point dans le repère 3D et le repère de la surface [19]

2.2.3.4. Breps Le terme signifie « boundary representation ». Il s’agit d’une collection de surfaces permettant de représenter un volume au moyen de sa surface.

2.2.3.5. Mesh Un mesh est une discrétisation d’une surface sous forme de maillage. Cette discrétisation consiste à approximer une surface au moyen d’une collection de face adjacente. Plus le maillage est fin, plus le mesh est fidèle à la surface initiale.

Figure 2-13 Comparaison de mesh à leur surface de référence [Illustration de l'auteur]

2.2.4. Structures de donnée Une des caractéristiques les plus importantes qu’offre Grasshopper est la création et la manipulation rapide de listes de données. Pour pleinement utiliser Grasshopper, il est important de comprendre la structure des informations y étant traitées. Les données peuvent être sauvegardées sous deux formes : les données persistantes et les données volatiles. Une donnée persistante est une donnée spécifiée par l’utilisateur. Elle est immuable si ce n’est par l’utilisateur lui-même. Les données persistantes servent généralement de paramètres de départ à un script.

Figure 2-14 Etat du composant après définitions des données [19]

Si le composant est orange, celui-ci ne contient aucune donnée et sera ignoré. Une fois celle-ci spécifiée le composant se grise et devient utilisable. Une description permet de vérifier les données.

Les données volatiles sont, elles, détruites et remplacées à chaque nouvelle solution du composant. Celles-ci sont généralement les étapes intermédiaires de calcul. Elles peuvent toutefois être sauvegardées comme données persistantes au moyen du menu contextuel.

Figure 2-15 Sauvegarde des données volatiles [19]

Grasshopper comprend de très nombreux types de données permettant de caractériser une géométrie. L’ensemble de ces types est décrit dans l’API RhinoCommon [20]. Ces données sont structurées sous forme de liste ordonnée. Elles permettent d’effectuer des opérations une à une. Les éléments de chaque liste seront traités avec les autres éléments partageant la même position dans leur liste respective.

Figure 2-16 Interaction des listes [Illustration de l’auteur]

Il est également possible d’imbriquer des listes dans d’autres listes en suivant une hiérarchie. Cette structuration est appelée arborescence.

Figure 2-17 Structure d'une arborescence [19]

La Figure 2-17 présente la structure d’une arborescence type. Une arborescence est structurée au moyen de branches et de feuilles. Chaque branche correspond à une liste en contenant une autre et est identifiée par une clé. Ces clés permettent de définir le chemin de la branche. Il s’agit de la position d’une branche dans l’arborescence. Ici par exemple, l’arborescence contient une branche principale dont le chemin est {0} cette branche en contient six autres ayant chacune une clé allant de 0 à 5. Ainsi chaque branche possède un chemin allant de {0; 0} à {0; 5}.

À l’extrémité des dernières branches se situent les feuilles. Les feuilles sont de simples listes de données comme décrites précédemment.

L’intérêt des arborescences est similaire à celui des listes. L’interaction entre deux arborescences se fera branche par branche permettant ainsi de structurer les données de manière bien plus efficace qu’avec une liste. Dans la Figure 2-18, on observe deux structures contenant chacune 24 éléments, une liste et une arborescence.

Figure 2-18 Comparaison entre liste et arborescence [19]

On s’aperçoit que dans une liste, l’ensemble des éléments sont liés. Ainsi pour accéder spécifiquement à la troisième colonne par exemple, il est nécessaire de déterminer les index à obtenir dans la liste. Or, dans le cas d’une arborescence, il suffit de récupérer la troisième branche pour obtenir la colonne souhaitée. Contrairement aux listes étant représentées par un trait simple lorsqu’ils sont branchés à un autre composant, les arborescences sont représentées par un trait pointillé. Facilitant ainsi la compréhension de la structuration des données à travers le script.

Liste

Arborescence

Figure 2-19 Comparaison des fils représentant les listes et les arborescences [Illustration de l'auteur]

Il est toutefois simple de modifier les données pour, notamment, passer d’une liste à une arborescence et inversement. Cela se fait en utilisant le menu contextuel disponible en faisant un clic droit sur un paramètre d’entrée ou de sortie comme présenté en figure 2-15. Celui-ci présente différentes options dont deux permettent de réaliser le passage de liste à arborescence : - Flatten : Aplatit une arborescence de manière à obtenir une liste en joignant les branches bout à bout - Graft : Convertit chaque élément de la liste en branche. Une branche contenant 𝑛𝑛 éléments deviendra donc une arborescence contenant 𝑛𝑛 branches de 1 élément. D’autres options sont également disponibles : - Reverse : Inverse les index des éléments d’une liste. Dans le cas des arborescences, les données des branches sont inversées, mais le chemin des branches n’est pas modifié. - Simplify : Simplifie les arborescences de manière à supprimer les branches vides - Expression : Réalise une opération sur chacun des éléments de la liste. Ces éléments sont notés 𝑥𝑥. Ainsi, si l’on souhaite doubler la valeur de chaque élément d’une liste de nombre l’expression sera 2 ∗ 𝑥𝑥.

2.2.5. Plugins

Étant donné la popularité de Grasshopper, il n’est pas étonnant que celui-ci soit complété de nombreux plugins développés par ses amateurs. La plupart de ces plugins peuvent être obtenus gratuitement via le site food4rhino.com proposant plus de 550+ applications prévues pour Grasshopper. Parmi toutes ces applications, certaines se sont imposées comme des indispensables et ont été grandement utiles dans le cadre de ce mémoire. Ce chapitre a pour but de décrire les plugins principaux ayant participé au développement du mémoire.

2.2.5.1. Kangaroo Kangaroo est un plugin développé par Daniel Pikerfi et contenant une collection d’algorithmes permettant de réaliser des simulations physiques faisant désormais pleinement partie de Grasshopper [21]. Ce moteur physique non-linéaire est directemengurt intégré dans l’interface Grasshopper. Cette intégration permet d’accélérer les simulations et d’augmenter l’interactivité. Les outils proposés par Kangaroo reposent sur une analyse dynamique du système jusqu’à ce que celui-ci atteigne une situation d’équilibre. L’éventail d’instruments proposés permet de définir à la fois des conditions sur le système telles que des supports, des déplacements imposés ou encore des variations de la longueur des éléments constituant le système. La versatilité et les possibilités de contraintes proposées par ce plugin expliquent sa popularité pour les opérations de recherche de forme. Spécifiquement, dans le cadre de ce mémoire, chacune des géométries a été vérifiée par le solveur Kangaroo au moyen d’un raccourcissement des câbles et d’une élongation des barres. Ces simulations ont permis de vérifier les résultats attendus ainsi que la stabilité des structures au second ordre.

Figure 2-20 Simulation d'un simplex [illustration de l’auteur]

Configuration initiale

Configuration finale

Figure 2-21 Résultat de la simulation d'un simplex [illustration de l’auteur]

La Figure 2-20 montre la simulation d’un simplex sans rotation au moyen de Kangaroo. La seule condition posée au système est l’élongation des barres de 20% de leur longueur initiale. On observe dans la Figure 2-21 la convergence de la géométrie vers le résultat attendu, c’est-à-dire un simplex dont la rotation relative entre la base est de 30°.

2.2.5.2. Galapagos Galapagos est un algorithme d’optimisation génétique développé par David Rutten [22]. Galapagos repose, comme sa description le suggère, sur les principes décrits par Charles Darwin. L’algorithme permet de maximiser ou minimiser un paramètre appelé fitness qui peut être considéré comme la survivabilité du génome. Ces génomes, eux, vont être les paramètres variés pour obtenir un optimum. Les génomes suivent des règles inhérentes à la théorie de l’évolution : - Les plus forts, au sens du fitness, survivent, - Les enfants ressemblent aux parents, - Des mutations surviennent. Galapagos fonctionne en définissant des sliders qui seront des génomes et un paramètre issu de la définition paramétrique, le fitness.

Figure 2-22 Génomes (en rose) et fitness (en vert) [illustration de l'auteur]

Le solveur Galapagos fonctionne par génération. La première génération correspond à une population aléatoire permettant d’accumuler des données permettant la caractérisation de ce système. Ces données peuvent être visualisées comme une surface que David Rutten nommera fitness landscape. Celui-ci spatialise dans un espace multidimensionnel les combinaisons de génome par rapport à leur valeur de fitness.

Figure 2-23 Fitness landscape [22]

Ensuite, chaque génération donnera naissance à la génération suivante dont la combinaison de génome sera proche. Plus une combinaison de génome maximise, ou minimise, le fitness, plus elle sera favorisée. Ce fonctionnement permet au fil des générations de s’approcher d’un optimum. Si la solution converge vers un pic, le solveur permettra également de prendre en compte d’autres maximas locaux par le biais de mutations permettant de vérifier que la solution vers laquelle l’algorithme converge est la meilleure.

Figure 2-24 Représentation du processus d'optimisation [22]

Bien que l’algorithme de Galapagos soit intrinsèquement peu précis et peu rapide, il permet de trouver une solution pour des problèmes moins stables. Ce fonctionnement par essai-erreur permet de trouver un terrain viable dans un fitness landscape escarpé.

2.2.5.3. Opossum Opossum est un plugin d’optimisation multiparamétrique développé par Thomas Wortmann [23]. Ce plugin a été spécifiquement conçu pour aider à l’optimisation lors des étapes de design du projet d’architecture. Son interface est proche de celle de Galapagos. On retrouve également une valeur, ici appelée objectif, qui devra être maximisée ou minimisée et les paramètres régissant le système, ici appelés variables.

Figure 2-25 Variables (en rose) et objectifs (en vert) [illustration de l'auteur]

Le solveur Opossum a pour but de proposer une alternative à Galapagos notamment afin d’améliorer l’efficacité temporelle des opérations d’optimisation. Celui-ci se base sur RBTOpt une

librairie 2 développée en python permettant de réaliser des optimisations dites black-box, c’est-à-dire ne nécessitant pas l’évaluation d’une dérivée, avec une meilleure efficacité temporelle que Galapagos.

2.2.5.4. Lunchbox Lunchbox est un plugin offrant de nombreux outils permettant la gestion de données et de géométries. Il est principalement utilisé pour la création de géométrie complexe, leur rationalisation ainsi que pour les opérations de pavage. Lunchbox offre également une série d’outils permettant de réaliser des opérations de machine Learning.

2.3. Scripts La génération de géométrie est un des objectifs principaux de ce mémoire. Dans les anciens mémoires, les géométries analysées – des empilements de cellules prismatiques – ne se différenciaient que par peu de paramètres : la cellule prismatique de référence, la longueur de l’assemblage, la hauteur de l’assemblage et le nombre de cellules composant l’assemblage. Les paramètres de modélisation sont en réalité bien plus nombreux. Ces possibilités inexplorées sont l’enjeu principal de cet objectif de génération de géométrie. La modélisation doit donc être la plus générale possible et offrir la plus grande diversité de paramètres possibles. À l’issue de ce mémoire, six typologies ont été explorées ayant chacune leurs paramètres et paramétrisations propres. Ce sous-chapitre a pour but de présenter les stratégies de paramétrisation des géométries développées et d’explorer une infime partie des géométries possibles.

2.3.1. Assemblage unidimensionnel rectiligne Cette typologie est basée sur un assemblage de cellules prismatiques. La modélisation paramétrique offre neuf paramètres régissant la géométrie de ce type d’assemblage :

Une librairie est un code contenant des outils spécifiques créés afin d’être utilisé dans d’autre programmes. 2

Configuration : Direction principale : Y Mode d’assemblage : Nœud sur nœud Polygone de référence : Carré Longueur de Longueur totale = 40[𝑚𝑚] l’assemblage : Largeur des prismes : Diamètre interne = 5[𝑚𝑚] Type de rotation : Alternée 45° Profil de l’assemblage : Linéaire

Configuration de référence

Nombre de cellules :

Paramètres

Variation #1

Variation #2

Direction principale

Direction principale : X Direction principale : vecteur [1,2,3]

Mode d’assemblage

Mode d’assemblage : nœud sur nœud

Mode d’assemblage : nœud sur câble

Polygone de référence : triangle

Polygone de référence : pentagone

Polygone de référence

Longueur de l’assemblage Longueur de l’assemblage : hauteur des cellules = 8,1[𝑚𝑚]

Longueur de l’assemblage : cellules régulières

Largeur des prismes

Largeur des prismes : Longueur des câbles = 8[𝑚𝑚]

Largeur des prismes : Diamètre externe = 5[𝑚𝑚]

Type de rotation

Type de rotation : alterné

Type de rotation : continue

Nombre de cellules : 2

Nombre de cellules : 10

Profil de l’assemblage

Nombre de cellules

Le script de création des assemblages unidimensionnels rectilignes fonctionne de la manière suivante :

2.3.1.1. Création des bases des cellules prismatiques L’assemblage étant constitué de cellules prismatiques du même type, l’ensemble de cette partie est fondé sur un seul polygone. Afin de définir sa position dans l’espace, le paramètre de direction de l’assemblage est utilisé. Il permet de définir un plan de construction. Ensuite, il convient de définir le polygone de référence. Cette définition se fait selon plusieurs paramètres :

Figure 2-26 Composant « Polygon » [illustration de l'auteur]

Le choix de la dimension étant assez contraignant, il est possible de définir différents paramètres à partir de relations trigonométriques utilisant le nombre de côtés 𝑛𝑛. Le script propose trois choix : - Le rayon externe 𝑟𝑟𝑒𝑒𝑒𝑒𝑒𝑒 - Le rayon interne 𝑟𝑟𝑖𝑖𝑖𝑖𝑖𝑖

- La longueur des câbles 𝑙𝑙𝑐𝑐

𝑟𝑟𝑒𝑒𝑒𝑒𝑒𝑒 = 𝑟𝑟𝑒𝑒𝑒𝑒𝑒𝑒 =

𝑟𝑟𝑖𝑖𝑖𝑖𝑖𝑖 𝜋𝜋 cos � � 𝑛𝑛 𝑙𝑙𝑐𝑐

𝜋𝜋 2. sin � � 𝑛𝑛

Le polygone créé est une polyligne. À partir de celle-ci nous allons créer les autres bases par translation. La distance de translation peut être également de trois types : - Définie par la hauteur d’une cellule - Définie par la longueur de l’assemblage - Définie de sorte que les cellules soient régulières – Ce développement est disponible en Annexe E– Les bases étant désormais placées à leur hauteur définitive, elles vont subir une rotation afin de créer les rotations relatives entre les différentes cellules composant l’assemblage. Cette rotation peut être de deux types : - Continue : la rotation relative augmente à chaque étage d’un angle 𝛼𝛼 défini dans le paramètre

Figure 2-27 Vues en plan et en perspective d'une rotation continue [illustration de l'auteur]

- Alternée : la rotation vaut par alternance 0° puis 𝛼𝛼

Figure 2-28 Vues en plan et en perspective d'une rotation alternée [illustration de l'auteur]

Enfin, on fait varier le profil de l’assemblage. Cette variation se fait par une mise à l’échelle de chacune des bases par rapport à son centre. La détermination du facteur de mise à l’échelle propre à chaque base est primordiale pour obtenir le profil désiré. Afin d’obtenir le résultat escompté, le composant graph mapper est utilisé. C’est un composant permettant de tracer des fonctions et d’ainsi en déterminer les valeurs pour des abscisses définies. Dans le cas qui nous occupe, son utilisation s’est vue détournée de manière à ce que la fonction représente le profil de l’assemblage. Ainsi, en utilisant une série de 𝑛𝑛 valeurs comprises dans l’intervalle [0; 1] pour déterminer la valeur de la fonction, on obtient les facteurs de mise à l’échelle correctes.

Figure 2-29 Utilisation du composant graph mapper afin d'obtenir les facteurs de mise à l'échelle [Illustration de l'auteur]

Figure 2-30 Assemblage correspondant à la figure 2-29 [Illustration de l'auteur]

2.3.1.2. Création des barres et des câbles intermédiaires La création des bases a permis d’obtenir une partie des câbles ainsi que l’ensemble des nœuds de la structure. L’algorithme est fait de telle sorte que les données soient ordonnées sous forme d’arborescence. Chaque branche correspond à un étage. Cette structure peut être visualisée comme étant une matrice. La figure représente la structure des points, notés 𝑃𝑃𝑃𝑃, pour un assemblage de 𝑛𝑛 cellules prismatiques dont le polygone de référence est d’ordre 𝑚𝑚: 37

é𝑡𝑡𝑡𝑡𝑡𝑡𝑡𝑡 ∈ [0, 𝑛𝑛]

⎧ ⎪

⎨ ⎪ ⎩

𝑖𝑖𝑖𝑖𝑖𝑖𝑖𝑖𝑖𝑖 𝑑𝑑𝑑𝑑 𝑝𝑝𝑝𝑝𝑝𝑝𝑝𝑝𝑝𝑝 ∈ [0,𝑚𝑚]

�� 𝑃𝑃𝑡𝑡{0 ;0} 𝑃𝑃𝑡𝑡{0 ;1} ⋯ 𝑃𝑃𝑡𝑡{0 ;𝑚𝑚−1} 𝑃𝑃𝑡𝑡{0 ;𝑚𝑚} ⎡ ⎤ 𝑃𝑃𝑡𝑡{1 ;1} ⋯ 𝑃𝑃𝑡𝑡{1 ;𝑚𝑚−1} 𝑃𝑃𝑡𝑡{1 ;𝑚𝑚} ⎥ ⎢ 𝑃𝑃𝑡𝑡{1 ;0} ⎢ ⎥ ⋮ ⋮ ⋱ ⋮ ⋮ ⎢𝑃𝑃𝑡𝑡 𝑃𝑃𝑡𝑡{𝑛𝑛−1 ;1} ⋯ 𝑃𝑃𝑡𝑡{𝑛𝑛−1 ;𝑚𝑚−1} 𝑃𝑃𝑡𝑡{𝑛𝑛−1 ;𝑚𝑚} ⎥ ⎢ {𝑛𝑛−1 ;0} ⎥ 𝑃𝑃𝑡𝑡{𝑛𝑛 ;1} ⋯ 𝑃𝑃𝑡𝑡{𝑛𝑛 ;𝑚𝑚−1} 𝑃𝑃𝑡𝑡{𝑛𝑛 ;𝑚𝑚} ⎦ ⎣ 𝑃𝑃𝑡𝑡{𝑛𝑛 ;0}

Si cette arborescence de points est utilisée pour créer des polylignes, cela résultera en une arborescence contenant 𝑛𝑛 + 1 branches dont chacune d’entre elles contient une polyligne. Ces polylignes correspondent aux bases de l’assemblage.

Si toutefois on transpose cette matrice, les branches ne correspondront plus à un étage mais à la position dans une liste. L’utilisation de cette nouvelle liste dans le composant polylignes permet de créer le reste des câbles de la structure. é𝑡𝑡𝑡𝑡𝑡𝑡𝑡𝑡∈ [0,𝑛𝑛]

𝑖𝑖𝑖𝑖𝑖𝑖𝑖𝑖𝑖𝑖 𝑑𝑑𝑑𝑑 𝑝𝑝𝑝𝑝𝑝𝑝𝑝𝑝𝑝𝑝 ∈ [0, 𝑚𝑚]

�� 𝑃𝑃𝑡𝑡{0 ;0} 𝑃𝑃𝑡𝑡{0 ;1} ⋯ 𝑃𝑃𝑡𝑡{0 ;𝑛𝑛−1} 𝑃𝑃𝑡𝑡{0 ;𝑛𝑛} ⎤ ⎧⎡ 𝑃𝑃𝑡𝑡{1 ;1} ⋯ 𝑃𝑃𝑡𝑡{1 ;𝑛𝑛−1} 𝑃𝑃𝑡𝑡{1 ;𝑛𝑛} ⎥ ⎪ ⎢ 𝑃𝑃𝑡𝑡{1 ;0} ⎢ ⎥ ⋮ ⋮ ⋱ ⋮ ⋮ ⎨ ⎢𝑃𝑃𝑡𝑡{𝑚𝑚−1 ;0} 𝑃𝑃𝑡𝑡{𝑚𝑚−1 ;1} ⋯ 𝑃𝑃𝑡𝑡{𝑚𝑚−1 ;𝑛𝑛−1} 𝑃𝑃𝑡𝑡{𝑚𝑚−1 ;𝑛𝑛} ⎥ ⎥ ⎪⎢ 𝑃𝑃𝑡𝑡{𝑚𝑚 ;1} ⋯ 𝑃𝑃𝑡𝑡{𝑚𝑚 ;𝑛𝑛−1} 𝑃𝑃𝑡𝑡{𝑚𝑚 ;𝑛𝑛} ⎦ ⎩ ⎣ 𝑃𝑃𝑡𝑡{𝑚𝑚 ;0}

En décalant l’ordre des points de l’arborescence initiale et en réappliquant la méthode, il est possible de créer le décalage dans les points permettant de créer les barres. La figure 2-31 illustre cette méthode.

Polyligne sur l’arborescence initiale

Polyligne sur l’arborescence transposée

Polyligne sur l’arborescence transposée avec shift

Superpositions de l’ensemble

Figure 2-31 Effet de la transposition de l'arborescence [Illustration de l'auteur]

2.3.1.3. Correction de la géométrie pour un assemblage nœud-sur-câble Le fonctionnement du script est, jusqu’ici, adapté à une modélisation nœud sur nœud. Pour réaliser un assemblage nœud-sur-câble, il est nécessaire de réaliser certaines corrections au modèle. 38

Le premier changement est lié aux bases. Celles-ci ne changent pas de position, mais, à l’exception des bases aux extrémités, voient leur nombre de côtés doublés de manière à permettre l’obtention d’un nœud supplémentaire. Ensuite, la position des barres et des câbles intermédiaires doit être changée afin que les barres atteignent les nœuds prévus. Ce changement de position correspond à la rotation d’une cellule sur deux par un angle :

Ce processus est représenté en

𝛼𝛼 =

𝜋𝜋 𝑛𝑛

Mode d’assemblage nœud sur nœud

Correction des bases

Rotation de la cellule centrale Figure 2-32 Passage d'un mode d'assemblage nœud sur nœud à nœud sur câble [Illustration de l'auteur]

2.3.2. Assemblage unidimensionnel le long d’une courbe Cette typologie est basée sur un assemblage de cellules prismatiques. La modélisation paramétrique offre sept paramètres régissant la géométrie de ce type d’assemblage : -

Courbe de référence, Mode d’assemblage -nœud sur nœud ou nœud sur câble-, Le polygone de référence de la cellule prismatique, La largeur de l’assemblage, Le type de rotation -continue ou alternée-, L’angle de rotation relative, Le nombre de cellules constituant l’assemblage.

Le script pour ce type d’assemblage est, en termes d’étapes, proche du script permettant de modéliser les assemblages unidimensionnels rectilignes :

Configuration : Mode d’assemblage : Nœud sur nœud Polygone de référence : Triangle Largeur des prismes : Diamètre interne = 5[𝑚𝑚] Type de rotation : Continue 30° Nombre de cellules : 9

Configuration de référence

Paramètres

Variation #1

Variation #2

Mode d’assemblage : nœud sur nœud

Mode d’assemblage : nœud sur câble

Polygone de référence : triangle

Polygone de référence : pentagone

Courbe de référence

Mode d’assemblage

Polygone de référence

Largeur des prismes Largeur des prismes : Longueur des câbles = 8[𝑚𝑚]

Largeur des prismes : Diamètre externe = 5[𝑚𝑚]

Type de rotation Type de rotation : alterné

Type de rotation : continue

Nombre de cellules : 3

Nombre de cellules : 16

Nombre de cellules

2.3.2.1. Création des bases des cellules prismatiques La création des bases suit une approche différente de celle de l’assemblage rectiligne. Contrairement à cette dernière, la création d’un assemblage le long d’une courbe ne garantit pas que l’ensemble des bases ait un plan de construction parallèle. Afin d’obtenir ces différents plans, la courbe est évaluée en un certain nombre de points permettant d’évaluer les tangentes en ces mêmes points.

Création des plans de construction le long d’une courbe

Création des plans de construction le long d’une ligne Figure 2-33 Comparaison des plans de construction entre un assemblage courbe et un assemblage rectiligne [Illustration de l'auteur]

Toutefois, comme le montre la figure 2-33, la création de ces plans est assez inconsistante. Les axes du plan, représentés en vert et en rouge, sont définis de manière assez imprévisible. Ce problème est réglé en alignant l’ensemble des plans au premier plan de la courbe. Ces plans une fois créés et alignés, accueillent la création du polygone de référence de la cellule prismatique constituant l’assemblage. Les paramètres de dimensions de ces bases sont les mêmes que ceux proposés pour les assemblages rectilignes. Les bases subissent ensuite une rotation d’un angle 𝛼𝛼 déterminé par le mode de rotation choisi : alterné ou continu. La modification du profil de l’assemblage n’a pas été mise en œuvre pour ce type d’assemblage. Bien que cela ne présente aucune difficulté particulière vis-à-vis de l’assemblage rectiligne, la définition du profil paraissait complexe à transposer sur la courbe. Ce paramètre a donc été écarté pour ne pas créer de confusion lors de la modélisation.

2.3.2.2. Création des barres et des câbles intermédiaires Cette étape est en tous points similaire à celle présentée au sous-chapitre 2.3.2.2 . La structure est également ordonnée sous forme d’arborescence dont chaque branche représente un étage. La transposition de cette matrice permet donc de créer l’ensemble des lignes manquantes. 42

2.3.2.3. Correction de la géométrie pour un assemblage nœud-sur-câble La géométrie précédente est adaptée à un type d’assemblage nœud-sur-nœud. Le mode d’assemblage nœud-sur-câble nécessite des changements au niveau des bases. Celles-ci sont créées de la même manière que pour la méthode nœud sur nœud à ceci près qu’elles voient le nombre de cotés doublé. L’ensemble des câbles restant et des barres est créé suivant la même méthode que pour l’assemblage nœud-sur-nœud. Toutefois, chaque cellule contenant donc deux fois trop d’éléments, se verra amputée de la moitié de ses câbles et barres. Cette suppression se fait de manière alternée d’étage en étage afin d’éviter que deux barres ne se joignent en un nœud.

Figure 2-34 Suppression des câbles et barres surnuméraires [Illustration de l'auteur]

2.3.3. Assemblage bidimensionnel plan Cette typologie se base sur le système de liaison développé par l’équipe de René Motro présenté précédemment. La modélisation paramétrique offre six paramètres : -

Le plan de construction La hauteur d’une nappe La largeur des cellules de tenségrité Le nombre de cellules dans la direction X Le nombre de cellules dans la direction Y Le nombre de nappes

Configuration : Plan de construction : XY Largeur des prismes : Diamètre interne = 10[𝑚𝑚] Nombre de cellule en X : 3 Nombre de cellule en Y : 3 Hauteur d’une nappe : 9 Nombre de nappes 1

Configuration de référence

Paramètres

Variation #1

Variation #2

Plan de construction : XZ

Plan de construction : YZ

Largeur des cellules : diamètre interne = 10[𝑚𝑚]

Largeur des cellules : diamètre externe = 10[𝑚𝑚]

Nombre de cellules en X : 1

Nombre de cellules en X : 4

Nombre de cellules en Y : 1

Nombre de cellules en Y : 5

Plan de construction

Largeur des cellules de la base inférieure

Nombre de cellules en X

Nombre de cellules en Y

Hauteur d’une nappe

Hauteur d’une nappe : 2[𝑚𝑚]

Hauteur d’une nappe : 10[𝑚𝑚]

Nombre de nappes : 2

Nombre de nappes :3

Nombre de nappes

2.3.3.1. Création de la grille supérieure et de la grille inférieure La grille inférieure est créée à partir du composant « Square » prenant en paramètre :

Figure 2-35 Composant « Square » [Illustration de l'auteur]

La longueur des cotés 𝑙𝑙𝑐𝑐 étant également assez restrictive, deux autres mesures sont utilisables au moyen d’une relation trigonométrique faisant intervenir le nombre de cotés 𝑛𝑛 du polygone : - Rayon du cercle circonscrit 𝑟𝑟𝑒𝑒𝑒𝑒𝑒𝑒 : - Rayon du cercle inscrit 𝑟𝑟𝑖𝑖𝑖𝑖𝑖𝑖 : 𝜋𝜋

- 𝑙𝑙𝑐𝑐 = 2. 𝑟𝑟𝑖𝑖𝑖𝑖𝑖𝑖 . tan � �

𝜋𝜋 𝑙𝑙𝑐𝑐 = 2. 𝑟𝑟𝑒𝑒𝑒𝑒𝑒𝑒 . sin � � 𝑛𝑛

𝑛𝑛

Ce composant nous renvoie une grille. Celle-ci prend la forme d’une arborescence de polylignes formant ladite grille. Chaque polyligne représente un carré. Afin de créer la grille supérieure, chacun de ces carrés subit une rotation autour de son centre d’un angle 𝛼𝛼 = 45°. Ces carrés sont ensuite mis à l’échelle d’un facteur 1⁄√2 toujours par rapport à leur centre. L’ensemble de transformations réalisé sur la grille initiale produit ainsi une grille diagonale, une diagrid, dont chaque carré est au centre des carrés de la grille initiale. Cette diagrid est ensuite déplacée perpendiculairement au plan de construction d’une distance correspondant à la hauteur d’une nappe.

Vue en plan

Perspective

Figure 2-36 Vues en plan et en perspective des grilles [Illustration de l'auteur]

2.3.3.2. Création des barres et câbles intermédiaires L’ensemble des câbles est issu de la liaison directe des carrés de la grille et ceux de la diagrid. La création des barres se fait de la même manière à ceci près que la liste des points de la diagrid doit être décalée d’une position.

Figure 2-37 Liaison des carrés de la grille et de la diagrid [Illustration de l'auteur]

2.3.3.3. Création des nappes La création des nappes se fait grâce à des opérations de symétrie et de translation. La première nappe est obtenue via l’algorithme présenté précédemment. La deuxième nappe est obtenue par symétrie de l’ensemble des câbles et barres. Le plan de symétrie est le plan auquel appartient la diagrid. Au-delà de deux nappes, la géométrie ne fait que se répéter. Cette dernière est donc obtenue par translation des câbles et barres perpendiculairement au plan de construction.

Une nappe

Deux nappes

Trois nappes

Quatre nappes

Figure 2-38 Vue en élévation d'assemblages ayant un nombre différent de nappes [Illustration de l'auteur]

2.3.4. Assemblage bidimensionnel non-plan Cette typologie est également basée sur le système de liaison développéeµ par l’équipe de René Motro. La modélisation offre six paramètres : -

Le plan de construction Surface de référence La hauteur de l’assemblage La largeur des cellules de tenségrité Le nombre de cellules dans la direction X Le nombre de cellules dans la direction Y

Configuration : Largeur des prismes : Diamètre interne = 3[𝑚𝑚] Nombre de cellule en X : 5 Nombre de cellule en Y : 5 Hauteur d’une nappe : 4

Configuration de référence

Paramètres

Variation #1

Variation #2

Plan de construction : XZ

Plan de construction : YZ

Largeur des cellules : diamètre interne = 3[𝑚𝑚]

Largeur des cellules : diamètre externe = 3[𝑚𝑚]

Nombre de cellules en X : 1

Nombre de cellules en X : 8

Nombre de cellules en Y : 1

Nombre de cellules en Y : 3

Surface de référence

Largeur des cellules de la base inférieure

Nombre de cellules en X

Nombre de cellules en Y

Hauteur d’une nappe

Hauteur d’une nappe : 2[𝑚𝑚]

Hauteur d’une nappe : 6[𝑚𝑚]

Le fonctionnement du script vis-à-vis des nappes non-planes est globalement le même que celui des nappes planes :

2.3.4.1. Création de la grille supérieure et de la grille inférieure La création des grilles se fait en deux étapes. La première est la création de la grille et de la diagrid. Elle se réalise exactement même manière que pour les assemblages bidimensionnels planes. La seconde consiste à projeter les grilles sur la surface de référence. Afin d’assurer le bon placement de la surface, celle-ci est centrée sur la grille. Une fois la projection réalisée, la diagrid est ensuite déplacée perpendiculairement au plan de construction d’une distance correspondant à la hauteur de l’assemblage.

2.3.4.2. Création des barres et câbles intermédiaires Les câbles intermédiaires sont obtenus de la même manière que pour les assemblages plans.

2.3.5. Anneau Cette typologie est basée sur le travail de Marcelo Pars [24]. La modélisation paramétrique offre sept paramètres : -

Le plan de construction Le rayon du cercle central Le rayon des cercles extérieurs L’épaisseur de l’anneau La largeur de la déformation de l’anneau central Le nombre de division La rotation additionnelle

Configuration :

Plan de construction : Diamètre du cercle central : Diamètre des cercles extérieurs : Epaisseur de l’anneau : Déformation du cercle central : Nombre de barres : Rotation supplémentaire : Variation #2

Configuration de référence

Paramètres

Variation #1

XY 10[𝑚𝑚] 8[𝑚𝑚] 5[𝑚𝑚] 1[𝑚𝑚] 15 15°

Plan de construction

Plan de construction : XZ

Plan de construction : YZ

Diamètre du cercle central : 8[𝑚𝑚]

Diamètre du cercle central : 12[𝑚𝑚]

Diamètre des cercles extérieurs : 4[𝑚𝑚]

Diamètre des cercles extérieurs : 8[𝑚𝑚]

Diamètre du cercle central

Diamètre des cercles extérieurs

Epaisseur de l’anneau

Epaisseur de l’anneau : 2[𝑚𝑚]

Epaisseur de l’anneau : 10[𝑚𝑚]

Déformation du cercle central : 0[𝑚𝑚]

Déformation du cercle central : 4[𝑚𝑚]

Nombre de barres : 6

Nombre de barres : 25

Rotation supplémentaire : 0°

Rotation supplémentaire : 30°

Déformation du cercle central

Nombre de barres

Rotation supplémentair e

Le script se base sur les étapes suivantes :

2.3.5.1. Création des cercles de référence L’anneau de tenségrité se base sur trois cercles servant de limites à la structure de tenségrité. Le premier cercle est le cercle central tracé dans le plan de construction. Une fois ce cercle créé, deux autres cercles extérieurs sont tracés de part et d’autre du cercle central afin de donner la largeur souhaitée à l’anneau de tenségrité.

Figure 2-39 Création des cercles [Illustration de l’auteur]

Les cercles étant composés de câbles, il est nécessaire de tendre les cercles entre les différents nœuds. Cela se fait au moyen du composant « Divide Curve ». Ce composant permet de diviser les cercles en autant de divisions que souhaitées. Le cercle central doit, quant à lui, subir le double du nombre de divisions. Ceci est dû au fait qu’il reçoit l’ensemble des barres de la structure. Cette dernière étant basée sur un mode d’assemblage nœud sur nœud, le nombre de nœud est nécessairement double.

Figure 2-40 Création des nœuds [Illustration de l'auteur]

Dans le cas où une rotation additionnelle est souhaitée, les points des cercles extérieurs subissent une rotation dans leur plan au niveau du centre du cercle. Il est également possible de déformer l’anneau central. Cette déformation se fait en déplaçant les points de part et d’autre de l’anneau, perpendiculairement au plan de construction. L’ensemble de ces points est utilisé afin de tracer l’ensemble des câbles formant les anneaux.

Figure 2-41 Création des câbles formant les cercles [Illustration de l'auteur[

2.3.5.2. Ajout des barres et câbles restants Les câbles restants permettent de lier les anneaux. Ceux-ci suivent le motif d’assemblage suivant :

Figure 2-42 Schéma d'assemblage d'un anneau [Illustration de l'auteur]

Les barres sont d’abord créées en connectant les points sur chacun des cercles extérieurs à leur point correspondant sur le cercle central. Les câbles restants sont quant à eux créés en liant l’extrémité de chaque barre avec l’autre extrémité de la barre suivante.

Figure 2-43 Création des câbles et barres [Illustration de l'auteur]

Figure 2-44 Géométrie finale par superpositions des géométries calculées [Illustration de l'auteur]

2.3.6. Boite Cette typologie est basée sur le travail de Marcelo Pars [25]. La modélisation paramétrique comporte sept paramètres : -

Plan de construction La longueur de l’assemblage selon la direction X La longueur de l’assemblage selon la direction Y La longueur de l’assemblage selon la direction Z Le nombre de divisions selon la direction X Le nombre de divisions selon la direction Y Le nombre de divisions selon la direction Z 54

Plan de construction : Longueur en X : Longueur en Y : Longueur en Z : Division en X : Division en Y : Division en Z :

Configuration de référence

Paramètres

Configuration : XY 15[𝑚𝑚] 45[𝑚𝑚] 12[𝑚𝑚] 4 4 4

Variation #1

Variation #2

Longueur en X : 10[𝑚𝑚]

Longueur en X : 20[𝑚𝑚]

Longueur en Y: 15[𝑚𝑚]

Longueur en Y : 30[𝑚𝑚]

Longueur en Z: 6[𝑚𝑚]

Longueur en Z: 16[𝑚𝑚]

Longueur en X

Longueur en Y

Longueur en Z

Division en X

Division en X : 2

Division en X : 6

Division en Y : 2

Division en Y : 6

Division en Z : 2

Division en Z : 6

Division en Y

Division en Z

Le script se base sur les étapes suivantes

2.3.6.1. Création des barres Dans une direction donnée, la longueur des barres est fixe. Ainsi, la première étape consiste à créer les barres qui serviront de référence pour toutes les autres étapes. Les lignes représentant les barres sont créées grâce au composant « Line SDL » signifiant « Line Start Direction Length ». Ce composant prend en entrée le point de départ de la ligne, un vecteur représentant la direction de la ligne et enfin sa longueur. Ce composant permet de créer facilement les lignes de référence en utilisant les axes du plan de construction ainsi que les dimensions de l’assemblage dans les différentes directions.

Figure 2-45 Barres [Illustration de l'auteur]

Ces lignes sont ensuite copiées à leur position finale permettant d’obtenir la structure de barre définitive.

2.3.6.2. Création des câbles Les câbles forment un maillage enveloppant les barres. Sur chacune des faces, il est nécessaire de relier les extrémités des barres adjacentes afin d’obtenir un maillage de câbles.

Figure 2-46 Câbles des faces [Illustration de l'auteur]

Les arêtes sont créées en reliant les extrémités des barres attenantes à l’arête, créant ainsi un entrelacs de câbles en dents de scie. Les sommets sont également un endroit de jonction particulier, il est nécessaire de lier les extrémités des barres contiguës aux côtés formant le sommet. Fort heureusement, cette étape est déjà réalisée durant la phase de création des câbles d’arête.

Figure 2-47 Câbles des arêtes [Illustration de l'auteur]

Figure 2-48 Géométrie finale obtenue par superposition [Illustration de l'auteur]

2.3.7. Algorithme Tachi Dans son article interactive freeform design of tensegrity [26] Tomohiro Tachi présente un algorithme permettant de convertir un mesh en une structure de tenségrité stable.

Figure 2-49 Structure de tenségrité obtenue à partir du lapin de Stanford [26]

La génération de la topologie se fait au moyen de trois étapes présentées en figure 2-50 : 1. Isoler les côtés et leur appliquer, indépendamment, une rotation d’un angle 𝜃𝜃 choisi arbitrairement compris dans l’intervalle [−𝜋𝜋; 𝜋𝜋] autour d’un axe passant par le centre des côtés et normal à la surface. Ces côtés sont des barres. 2. On connecte les extrémités des barres avec des câbles pour créer un polygone constitué de 𝑚𝑚 côtés correspondant à un sommet de degré 𝑚𝑚 3. On connecte les extrémités des barres avec des câbles pour créer un polygone constitué de 𝑛𝑛 côtés correspondant à une face composée de 𝑛𝑛 arêtes.

Figure 2-50 Création de la topologie d'un tétraèdre régulier en une structure de tenségrité icosaédrique régulière pour un angle 𝜃𝜃 = 45° [26]

Afin d’assurer la stabilité des structures obtenues, il est nécessaire d’effectuer une opération de recherche de forme développée par Tomohiro Tachi dans son article. Cette recherche de forme se base sur la méthode de densité de force qui est, quant à elle, abordée en profondeur dans plusieurs articles de Sergio Pellegrino notamment « Structural computations with singular value decomposition of the equilibrium matrix » [27]. Malheureusement, par manque de temps, seule l’étape de création de la topologie a été mise en œuvre. Elle est utilisable sous la forme d’un composant « GhPython Script » contenant l’ensemble du code.

3. Plugin Grasshopper Ce chapitre présente le développement du plugin Grasshopper. Tout d’abord, le contexte tant historique que logiciel sera abordé mettant en évidence une série de problèmes. Par la suite, une série de solutions ayant été envisagées est présentée afin de déterminer la méthode la plus intéressante dans le cadre de ce mémoire. Enfin, chaque composant verra son fonctionnement, ses entrées et ses sorties décrites afin d’en comprendre le fonctionnement. Dans ce chapitre, afin de d’apporter plus de nuances aux éléments composant une structure, les termes « buton » et « barre » seront à nouveau distingués.

3.1. Contexte Dans le cadre de son mémoire, Marc Eliaers a développé un code MATLAB permettant le calcul non linéaire de structures de tenségrité [28]. MATLAB, bien qu’étant un langage très performant pour le calcul scientifique, est un logiciel propriétaire. C’est-à-dire qu’il appartient à la compagnie MathWorks. Ceci implique un certain nombre de restrictions dans l’utilisation du programme. Afin de pallier ce problème, la décision d’utiliser un langage de programmation étant sous licence libre a été prise au sein du pôle GCE de l’UCLouvain. Le choix s’est porté sur le langage Python, spécifiquement sa version 3.5 au moment où Jonas créait sont programme. Ce choix a été fait en tenant, notamment, compte du contexte scientifique actuel au sein duquel Python peut être qualifié d’étoile montante. Python est régulièrement utilisé dans différentes disciplines et est même le langage de référence pour certains domaines comme par exemple le développement de logiciel de deep learning et de machine learning. Cet engouement autour du langage lui permet d’être régulièrement étoffé par de nombreuses extensions développées par ses utilisateurs. La réécriture du code MATLAB en Python a été réalisée par Jonas Feron lors de son mémoire [29]. Il a par la suite été réutilisé et amélioré par Lindy Boucher et Igor Bouckaert lors de ce mémoire. Il est donc naturel que les développements de ce mémoire se basent sur les codes Python préexistants afin de pouvoir réaliser des analyses de structures sur Grasshopper.

3.2. Problématiques La programmation au sein de Grasshopper implique un certain nombre de restrictions. Deux d’entre-elles sont particulièrement contraignantes. La première contrainte est la liste des langages de programmations supportés. L’interface Grasshopper et Rhinoceros en supportent trois : Visual Basic .NET, le C# et Python. Ce support se manifeste sous la forme de trois composants permettant d’accéder à une interface de programmation, présentée en figure 3-2, via un double clic sur le composant.

Figure 3-1 Composants « VB Script », « C# Script » et « GhPython Script » [Illustration de l'auteur]

La possibilité d’utiliser Python au sein de Grasshopper est une bonne nouvelle. Cependant, il ne s’agit ni de la version 3.5 ni d’une version officielle de Python. Grasshopper utilise une implémentation de Python appelée IronPython. Celle-ci a pour particularité d’être basée sur Python 2.7 et de permettre l’utilisation des librairies .NET développées pour Visual Basic .NET ou C#. Cette différence de version à de fortes implications sur la capacité de réutilisation du code développé lors des précédents mémoires. En effet, lors d’une mise-à-jour d’un langage la rétrocompatibilité est en grande partie assurée. Un code développé en utilisant Python 2.7 sera donc compatible avec Python 3.5. Toutefois, l’inverse n’est pas assuré. Un code développé en Python 3.5 n’est pas nécessairement compatible avec Python 2.7. Il a donc été nécessaire de traduire l’entièreté du code afin d’en assurer la compatibilité.

Figure 3-2 Interface de programmation du composant « GhPython Script » [Illustration de l'auteur]

Deuxièmement, la librairie Python NumPy n’est pas utilisable au sein de Grasshopper. NumPy est une extension de Python open source permettant de réaliser des opérations mathématiques tant sur des nombres que sur des matrices. Elle est développée depuis 2005 et est régulièrement mise à jour. Les fonctionnalités proposées et la robustesse de cette extension lui ont construit une très bonne réputation faisant de NumPy une librairie indispensable de Python pour le calcul scientifique. Le code Python initié par Jonas Feron n’y fait pas exception. Les opérations permettant de créer les différentes matrices et vecteurs ainsi que de résoudre les systèmes présentés au chapitre 4 reposent entièrement sur NumPy. Ne pas pouvoir l’utiliser dans Grasshopper constitue donc un obstacle majeur.

3.3. Calcul scientifique au sein de Grasshopper Afin de pouvoir implémenter les analyses numériques sur Grasshopper, il est nécessaire de pouvoir créer des matrices et d’y appliquer des opérations mathématiques. Ainsi, il est nécessaire de pouvoir utiliser NumPy au sein des scripts Python. Afin de permettre cela, plusieurs solutions ont été envisagées voici les plus notables :

3.3.1. GH_CPython GH_CPython est une extension Grasshopper développée par Mahmoud Adbel Rahman [30] permettant l’utilisation de l’ensemble des fonctionnalités de Python au sein de Grasshopper. Il est possible d’utiliser n’importe quelle version de Python mais également d’importer des librairies extérieures à Grasshopper et Rhino. Cette extension permet donc de corriger les deux problématiques évoquées au sous-chapitre 3.2. A savoir l’obligation d’utiliser la version 2.7 de Python et l’impossibilité d’importer des librairies externes telles que NumPy.

Figure 3-3 Création d'une matrice aléatoire utilisant NumPy [Illustration de l’auteur]

Toutefois, GH_CPython apporte également trois restrictions majeures. Premièrement, les résultats retournés par un script écrit au sein de ce composant sont obligatoirement convertis en texte. La matrice retournée par le paramètre output_ à la figure 3-3 n’est en réalité pas une matrice mais une représentation textuelle de la matrice. Deuxièmement, certains types de données Grasshopper ne sont pas supportés par GH_CPython. Il est par exemple impossible d’utiliser une ligne comme paramètre d’entrée. Cette incompatibilité est présentée à la figure 3-4. On y observe un script très simple permettant d’obtenir les extrémités d’une ligne exécuté au moyen de GH_CPython et de GhPython. On constate que le composant GH_CPython est rouge et ne renvoie aucun résultat ce qui signifie qu’il y a une erreur. Tandis que le composant GhPython effectue la tâche sans difficulté.

Figure 3-4 Comparaison d'un script permettant d'obtenir les extrémités d'une ligne avec GH_CPython et GhPython [Illustration de l'auteur]

Enfin, GH_CPython ne permet ni l’utilisation de la librairie RhinoCommon [20] ni celle de la librairie RhinoScriptSyntax. RhinoCommon est un plugin de Rhino permettant la création et la 63

modification de géométrie au moyen de scripts écrits en Visual Basic .NET, C# et Python. RhinoScriptSyntax est une librairie Python développée par les équipes de McNeel, l’éditeur de Rhinoceros, proposant une série d’outils se basant sur la librairie RhinoCommon Le premier problème est relativement minime étant donné qu’il est possible avec Python de convertir des données d’un type à un autre sans grande difficulté. On peut donc reconvertir les données sous forme de texte pour leur rendre leur type initial. Les deux autres restrictions sont, elles, bien plus contraignantes. L’impossibilité d’utiliser les outils de programmation propres à Grasshopper et d’interagir directement avec les géométries rend cette solution peu intéressante.

3.3.2. GH Python Remote GH Python Remote est un composant Grasshopper développé par Pierre Cuvilliers au MIT permettant l’utilisation de librairies externes au sein de l’interface Grasshopper. Ce composant crée une instance de Python s’exécutant dans une fenêtre externe et lançant l’ensemble des opérations nécessitant les librairies externes. Le composant, à droite dans la figure 3-5, contient trois paramètres d’entrée : - location : position de l’interpréteur Python 2.7 - run : un interrupteur permettant d’activer, ou non, le composant - modules : liste des librairies à importer dans Grasshopper La figure 3-5 montre un script utilisant la fonction « identity » de NumPy permettant de créer une matrice identité. On observe que le résultat est correct.

Figure 3-5 Création d'une matrice identité en utilisant NumPy grâce à GH Python Remote [Illustration de l'auteur]

Cette solution présente de nombreux avantages. Tout d’abord, elle corrige les problèmes que présente GH_CPython. Le composant permet d’utiliser les librairies externes au sein du composant « GhPython Script » présent nativement dans les versions récentes de Grasshopper. Il n’y a donc pas de problème de support de RhinoCommon et RhinoScriptSyntax ou d’interaction avec les géométries créées dans Grasshopper. Néanmoins, le composant implique également certaines restrictions. Premièrement, le composant nécessite l’utilisation de Python 2.7 ce qui, dans la mesure où c’est également la version utilisée dans Grasshopper, ne représente pas un problème majeur. Deuxièmement, l’interface implique la présence d’une fenêtre autre que celle de Grasshopper. Ce qui crée un décalage avec l’utilisation classique de Grasshopper bien que cette fenêtre puisse être mise en arrière-plan. Cette fenêtre permet de suivre les scripts lancés de manière externe à Grasshopper et ainsi permettre de vérifier le fonctionnement du programme. Troisièmement, le composant doit être présent et lancé manuellement sur chaque script Grasshopper ce qui implique une surcharge initiale de ce dernier ainsi qu’une opération supplémentaire pour l’utilisateur. Cette nécessité d’avoir un composant supplémentaire implique l’impossibilité de compiler les codes utilisant des librairies externes pour en faire des composants Grasshopper. 64

Ce dernier point est la raison pour laquelle cette solution a été écartée. En effet, on souhaite à terme avoir un plugin contenant un ensemble de composants indépendants. Il est donc essentiel de pouvoir compiler chacun de ces composants.

Figure 3-6 Interface Grasshopper avec la fenêtre GH Python Remote [Illustration de l'auteur]

3.3.3. COMPAS COMPAS est un framework 3 développé pour Python par le Block Research Group, une cellule de recherche de l’ETH Zurich [31]. Dans ce cas de figure, COMPAS est un framework proposant des outils permettant la visualisation, le traitement et l’interaction avec des structures de données et des objets géométriques dans le cadre d’un logiciel de dessin assisté par ordinateur. Les outils développés dans COMPAS se veulent généraux. Cette volonté se manifeste sous la forme d’un module central contenant un ensemble de méthodes indépendantes de tout logiciel de dessin assisté. Ce noyau est complété par une série de modules additionnels permettant d’intégrer COMPAS aux différents logiciels de dessin assisté par ordinateur : - compas_blender : module permettant l’intégration dans le logiciel de modélisation 3D Blender - compas_rhino : module permettant l’intégration dans le logiciel de modélisation 3D Rhinoceros - compas_ghpython : module permettant l’intégration aucomposant « GhPython Script » de Grasshopper

Un framework désigne un ensemble de fonctions servant à créer les bases ainsi que les principes directeurs de tout ou d’une partie d’un logiciel. 3

Il est donc possible d’utiliser COMPAS au sein de Rhinoceros et de Grasshopper. Cette intégration permet d’utiliser les librairies RhinoCommon et RhinoScriptSyntax et par conséquent de créer et d’interagir avec les données géométriques. Toutefois, bien que COMPAS soit intégré dans différents logiciels de dessin assisté par ordinateur, il est toujours soumis aux limitations de ces environnements. Notamment, pour Rhinoceros et Grasshopper, celles concernant l’importation de librairies externes. Afin de contourner ce problème, COMPAS propose deux solutions permettant d’utiliser des codes externes à Grasshopper sous condition qu’ils soient compatibles avec Python 2.7. La première est appelée « XFunc » et permet de lancer des codes externes à Grasshopper faisant appel à des librairies externes. L’utilisation de cette solution est particulièrement efficace, bien que consommatrice en ressources, pour utiliser des codes impliquant de longs temps d’exécutions. La deuxième solution est de mettre en place un proxy. Le fonctionnement de ce dernier est simple. Le Proxy peut être vu comme un médiateur entre Grasshopper d’un côté et Python de l’autre. Grasshopper agit comme une boite fermée ne pouvant réaliser qu’un certain nombre d’opération. De l’autre côté, Python, un environnement totalement ouvert, peut effectuer ces actions. Il est donc intéressant d’effectuer un maximum d’opérations dans l’interface Grasshopper et les opérations pour lesquelles c’est nécessaire dans Python. C’est ce rôle que joue le proxy.

Figure 3-7 Représentation du fonctionnement d'un proxy [Illustration de l'auteur]

Ce transfert de données d’un environnement à un autre nécessite une standardisation de ces dernières. Ce procédé s’appelle la sérialisation et consiste à convertir les données en une donnée compréhensible par les deux parties. C’est une opération consommatrice de ressources impliquant une restriction majeure. La sérialisation est une procédure systématique, il est donc indispensable que les types soient supportés par les deux parties. Il est ainsi essentiel que les données transférées soient des types primitifs de Python. Ces derniers sont présents dans la documentation de Python [32]. Au sous-chapitre 2.2.4 il a été établi qu’il existait deux manières de stocker des données dans Grasshopper : sous forme de données persistantes ou sous forme de données volatiles. Etant donné qu’une majorité des données d’un script sont stockées de manière volatile, l’ensemble des composants est fortement susceptible d’être réexécuté afin de mettre à jour les données volatiles. Ainsi, là où la « XFunc » est plus efficace d’un point de vue temporel pour exécuter de manière ponctuelle un script lourd, l’utilisation de proxy permet quant à elle d’exécuter plus rapidement et de nombreuses fois un script. Le proxy est donc une solution bien plus adaptée au fonctionnement de Grasshopper. En conclusion, les nombreux outils proposés par COMPAS permettent de facilement contourner les restrictions évoquées précédemment à l’exception de celle sur la version de Python utilisée. De plus, l’utilisation de COMPAS permet de séparer la structure du programme de calcul en trois entités distinctes. Cette séparation sera présentée et approfondie dans le sous-chapitre3.4. Il s’agit donc de la solution qui a été choisie.

3.3.4. Mix C#/Python La piste d’un programme mixte utilisant les deux langages C# et Python est possible. C’est la méthode qui a été utilisée par Thomas Wortmann pour développer Oppossum comme évoqué dans le sous-chapitre 2.2.5. Malheureusement, cette piste a été découverte tardivement et n’a donc pas pu être mise en œuvre. De plus une telle interaction entre deux langages demande un niveau poussé de connaissances en programmation. Il est néanmoins important de signaler qu’une telle solution est envisageable et offre potentiellement de nombreux avantages tout en montrant une bonne efficacité temporelle si l’on s’en tient à Opossum.

3.4. Conception du programme Le logiciel final développé dans le cadre de ce mémoire est un plugin Python contenant 58 composants. Chacun d’eux est décrit au sous-chapitre 3.5. Initialement, ce plugin devait être entièrement dédié au calcul de structures de tenségrité. Toutefois, la décision a été prise d’en faire un programme général de calcul de structures rotulées. Afin d’appuyer cette décision, le programme propose une série de composants permettant de créer l’ensemble des éléments composant une structure. Cette volonté de décomposition de la structure se traduit dans la programmation. Notamment par la programmation orientée objet qui sera développée au sous-chapitre 3.4.2.

3.4.1. Architecture du programme Comme vu précédemment, une série de restrictions a dû être prises en compte afin de permettre de réaliser des calculs numériques. A cette occasion, le code a été entièrement réécrit, tout en en gardant la démarche, afin de correspondre au fonctionnement de Grasshopper. La structure du programme a subi de nombreux changements et se rapproche désormais d’une architecture modèle-vue-contrôleur. La figure 3-8 présente le fonctionnement du logiciel créé :

Figure 3-8 Structure du logiciel [Illustration de l'auteur]

On y retrouve trois types de modules ayant des responsabilités différentes :

3.4.1.1. Modèle Le modèle contient les données à afficher. Cette structure de données peut être simple ou au contraire très complexe. Le programme utilise des nouveaux types spécifiquement créés pour contenir les données caractérisant les structures. On retrouve notamment : les matériaux, les sections, les barres, etc.

3.4.1.2. Vue Il s’agit de la partie visible de l’interface utilisateur. La vue permet d’afficher le modèle. Dans le cas de ce programme, cette fonction est assurée par les interfaces de Rhinoceros et de Grasshopper. L’interface de Rhinoceros permet d’afficher les géométries mais également de modifier l’ensemble des paramètres d’affichage. L’interface de Grasshopper permet, elle, d’afficher les composants mais également les données ainsi que l’ensemble des composants dans le script. La vue a également pour rôle d’afficher les erreurs transmises par le contrôleur ainsi que d’activer le fonctionnement de celui-ci.

3.4.1.3. Contrôleur Le contrôleur est la partie modifiant les données du modèle. Il exécute les tâches imposées par l’utilisateur au moyen de la vue. Il s’agit de la majorité des opérations effectuées par le programme. Le contrôleur est un ensemble de composants développés en Python et faisant appel au proxy de COMPAS pour accéder aux méthodes de calcul scientifique.

3.4.2. Programmation orientée objet Le programme initié par Jonas Feron utilise une programmation dite orientée objet. La programmation orientée objet consiste en la définition et l’interaction d’éléments appelés objets. Un objet peut représenter des choses physiques mais également des concepts ou des idées. Afin de créer un objet, il est nécessaire de définir une classe. La classe peut être comparée à un plan de fabrication d’un objet. Elle reprend l’ensemble des caractéristiques d’un objet et permet sa création. Un objet est une instance 4 de classe. La programmation objet est intéressante dans le cadre de grand logiciel. Bien que les performances d’un code faisant intervenir des objets sont légèrement moins bonnes qu’un programme n’en utilisant pas. Cette légère perte de performance permet d’améliorer grandement la capacité de réutilisation du code, son entretien ainsi que sa lisibilité. De plus, la programmation orientée objet d’ajouter permet bien plus facilement des fonctionnalités au programme en créant de nouvelles classes et en définissant les interactions entre les classes. Le programme développé au cours des derniers mémoire utilise trois classes : - Structure_class - Prestressed_class - Simplex_class La classe « Simplex_class » se base sur la classe « Prestressed_class » tandis que cette dernière se base sur la classe « Structure_class ». Ce lien de parenté entre les différentes classes s’appelle « héritage ». L’héritage implique, entre autres, que l’ensemble des caractéristiques d’une classe mère

Une instance est un objet dont le comportement et l’état initial correspondent à une classe

sera présente dans la classe fille. Cette imbrication de classe permet au programme de facilement créer ou ajouter des fonctionnalités précises au fil des héritages. Etant donné la nécessité de réécrire l’intégralité du code, la structure de celui-ci a également été révisée. Désormais, le code est composé de trois classes principales indépendantes s’approchant de la logique utilisée dans Grasshopper : - « Node » - « Element » - « Structure » Ces classes permettent de créer des objets représentant mieux la composition réelle d’une structure. Une structure est composée d’éléments étant eux-mêmes définis par des nœuds correspondant aux extrémités. Cette logique est différente de celle qui la précéde. Désormais il ne s’agit plus d’ajouter des fonctionnalités à une classe unique mais bien de définir des briques constituant d’autres classes. Ainsi, les classes « Cable », « Strut » et « Bar » sont toutes basées la classe « Element ». L’héritage de la classe « Element » permet d’assurer la compatibilité avec la classe « Structure » tout en permettant l’ajout de fonctionnalités.

3.5. Composants Le plugin comprend 58 composants répartis dans neuf catégories : -

Géométrie Modèle Charges Analyse Optimisation Résultats Affichage Outils Paramètres

Ce chapitre a pour but de décrire leur fonctionnement. L’ensemble des descriptions est également disponible sur chacun des composants. La méthode pour les afficher est celle présentée au souschapitre 2.2.2.

3.5.1. Géométrie La catégorie géométrie contient les composants permettant de créer diverses géométries se basant sur les scripts Grasshopper décrits au chapitre 2. Ces derniers sont obtenus en plaçant chacun des scripts dans un cluster. Il s’agit d’un composant en contenant un autre. Il est ainsi possible de compresser de grandes définitions en de simples composants contenant un certain nombre de paramètres et d’entrées. L’exemple du cluster équivalent au script de création de la géométrie des assemblages bidimensionnel plan est présenté en Figure 3-9.

Figure 3-9 Script de création des assemblages bidimensionnels plans et cluster équivalent [Illustration de l'auteur]

Les paramètres d’entrée sont les mêmes que ceux définissant le script. Le lecteur est donc invité à relire le chapitre 2 pour une description complète des paramètres d’entrée. Pour l’ensemble des composants de la catégorie géométrie, les paramètres de sorties sont les lignes représentant les butons et les câbles ainsi que les points représentant les nœuds.

3.5.2. Modélisation La catégorie modélisation contient les composants permettant de créer la structure. Le fonctionnement de ces composants suit une logique similaire à celle du code Python permettant le calcul des structures. Les composants permettent de créer un ensemble de constituants d’une structure. Le résultat final de la modélisation est une structure. Celle-ci est obtenue au moyen du composant « Structure » :

Figure 3-10 Composant « Structure » [Illustration de l'auteur]

Ce composant prend en entrée trois paramètres représentant ses constituants : - Pt : Les nœuds de la structure sous forme de points. - Elem : Les éléments composant la structure. Ils peuvent être soit des câbles, des butons ou des barres. - Spt : Les supports permettant de définir les conditions aux appuis de la structure. Les éléments constituant la structure peuvent être obtenus au moyen de trois composants :

Composant « Cable »

Composant « Strut »

Composant « Bar »

Figure 3-11 Composants permettant la création des sables, butons et câbles [Illustration de l'auteur]

Le programme différencie trois types d’éléments : - Le câble est un élément n’étant stable qu’en traction. Dans le cas où un câble est en compression à l’issue du calcul, l’utilisateur est averti de manière à pouvoir identifier les câbles problématiques. - Le buton est un élément ne pouvant résister qu’à de la compression. Dans le cas où un buton est en traction à l’issue du calcul, l’utilisateur est averti de manière à pouvoir identifier les butons problématiques. - La barre est un élément fonctionnant autant en traction qu’en compression. Tous ces composants prennent en entrée les mêmes paramètres à savoir : - Ln : La ligne représentant l’élément - CS : Les caractéristiques de la section de l’élément - Mat : Les caractéristiques du matériau de la section Les caractéristiques des sections des différents éléments sont stockées dans des objets « CrossSection » qui peuvent être créés au moyen de deux composants :

Composant « Circular Cross Section »

Composant « Square Cross Section »

Figure 3-12 Composant « Circular Cross Section » et « Square Cross Section » [Illustration de l'auteur]

Ils partagent également les paramètres d’entrée identiques : - D et W : La largeur de la section en [𝑐𝑐𝑐𝑐] par rapport aux parois extérieures. - t : L’épaisseur de la section en [cm].

Afin de définir les éléments, il est également nécessaire de définir les caractéristiques du matériau. Ces dernières sont définies dans un objet « Material ». Celui-ci peut être créé au moyen du composant « Create Material ».

Figure 3-13 Composant « Create Material » [Illustration de l'auteur]

Ce composant prend en entrée l’ensemble des caractéristiques du matériau utilisé lors du calcul : 71

Name : Le nom du matériau. E : Le module de Young en [𝑀𝑀𝑀𝑀𝑀𝑀]. Fy : La limite d’élasticité 𝑓𝑓𝑦𝑦 du matériau en [𝑀𝑀𝑀𝑀𝑀𝑀]. Rho : La masse volumique du matériau en [𝑘𝑘𝑘𝑘⁄𝑚𝑚3 ].

Néanmoins, il est peu pratique de devoir définir chaque matériau manuellement surtout lorsque certains matériaux sont très régulièrement utilisés. Afin de pallier le problème, le programme contient le composant « Material List » qui est un catalogue de matériaux. Ceux-ci sont disponibles dans le menu contextuel disponible via un clic droit sur le composant.

Figure 3-14 Composant « Material List » [Illustration de l'auteur]

Actuellement, le composant contient quatre matériaux : -

L’acier S235 L’acier S275 L’acier S355 L’aluminium

Cette liste peut toutefois être facilement étoffée. L’implémentation des matériaux ne présentant aucune difficulté. L’ensemble des composants permettant de définir la géométrie de la structure ont été présentés. Afin que la structure soit stable, il est nécessaire d’en définir les conditions aux appuis. Cela se fait au moyen du composant « Support » :

Figure 3-15 Composant « Support » [Illustration de l'auteur]

Celui-ci prend en entrée quatre paramètres : -

Pt : Le point d’application du support x : L’état de blocage de l’appui dans la direction X. Si la valeur est True, le support est bloqué. y : L’état de blocage de l’appui dans la direction Y. Si la valeur est True, le support est bloqué. z : L’état de blocage de l’appui dans la direction Z. Si la valeur est True, le support est bloqué. display : Permet d’afficher le support à des fins de vérification. Si la valeur est True le support est affiché. Comme le montre la figure 3-16, l’affichage prend la forme des vecteurs bleus appliqués aux nœuds bloqués et correspondant aux degrés de liberté verrouillés.

L’état de blocage du support est décrit par un message sous le composant.

Figure 3-16 Affichage des appuis pour une passerelle de tenségrité dont les nœuds extrêmes sont simplement appuyés [Illustration de l’auteur]

La définition de chaque support peut être une longue opération. Le plugin propose trois alternatives à ce composant :

Composant « Support X »

Composant « Support Z »

Figure 3-17 Composants « Support X », « Support Y » et « Support Z » [Illustration de l'auteur]

Ces trois composants ne nécessitent qu’un point d’application. La direction du blocage étant déjà définie. L’ensemble de ces composants permet à l’utilisateur un grand contrôle sur les paramètres de modélisation de la structure. Afin de compléter l’éventail d’outils proposé, le programme dispose également de cinq composants permettant de décomposer les structures, les éléments, les supports, les sections et les matériaux afin d’en récupérer les caractéristiques :

Composant « Disassemble Structure »

Composant « Disassemble Element»

Composant « Disassemble Material »

Composant « Disassemble Cross Section »

Composant « Disassemble Support »

Figure 3-18 Composants permettant de récupérer les caractéristiques des objets présentés précédemment [Illustration de l'auteur]

3.5.3. Charges La structure étant créée, il est nécessaire de définir les charges ponctuelles qui s’y appliquent ainsi que la précontrainte agissant dans la structure. La catégorie « charges » reprend ainsi des composants permettant de caractériser la précontrainte et les charges. Tout d’abord, quatre composants sont disponibles afin de définir des forces agissants sur la structure. Le premier permet la prise en compte de la gravité dans le calcul de la structure et donc le poids propre. Le programme se voulant général, il semble important d’offrir cette possibilité.

Figure 3-19 Composant « Gravity » [Illustration de l'auteur]

La prise en compte du poids se traduit par le calcul du poids de chaque élément composant la structure. Ensuite, la moitié de ce poids est appliquée sous la forme de charge ponctuelle sur la première extrémité tandis que l’autre moitié est appliquée sous forme de charge ponctuelle sur l’autre extrémité. Il est également possible d’appliquer d’autres charges nodales. Le composant « Load » permet de définir des charges ponctuelles à appliquer à la structure.

Figure 3-20 Composant « Load » [Illustration de l'auteur]

Ce dernier prend en entrée trois paramètres : - Pt : Point sur lequel est appliquée la charge ponctuelle. Ce point doit coïncider avec un nœud de la structure. - V : Vecteur représentant la charge ponctuelle tant en termes de direction que d’intensité. La norme de ce vecteur correspond à la valeur de la force en [𝑘𝑘𝑘𝑘] - Display : Permet d’afficher la force à des fins de vérifications. Si la valeur est True, la force est affichée. Comme le montre la figure 3-21, les charges s’affichent sous la forme de vecteurs verts appliqués aux nœuds dont l’intensité est affichée.

Figure 3-21 Affichage des charges ponctuelles de 3kN dans la direction (1; 1; -2) appliquées sur la première moitié des nœuds d’une passerelle de tenségrité [Illustration de l’auteur]

Néanmoins, comme évoqué pour la définition des supports, la définition d’une charge peut être fastidieuse notamment lors de la création du vecteur. Afin de pallier ce problème, trois composants sont disponibles afin d’appliquer une charge ponctuelle dans une direction définie.

Composant « Load X »

Composant « Load Y »

Composant « Load Z »

Figure 3-22 Composants permettant d'appliquer une charge ponctuelle dans une direction prédéfinie [Illustration de l’auteur]

Les paramètres d’entrée sont les mêmes que ceux présentés pour le composant « Load » excepté qu’il n’est plus nécessaire d’utiliser un vecteur pour le deuxième paramètre. La direction étant fixée par le composant, seule l’intensité de la force en [𝑘𝑘𝑘𝑘] est requise.

Par facilité, les composants liés à l’application de précontrainte ont également été regroupés dans la catégorie charges. La précontrainte est appliquée au moyen du composant « Prestress » présenté à la figure 3-23.

Figure 3-23 Composant « Prestress » [Illustration de l'auteur]

Celui-ci prend deux paramètres en entrée : - Ln : La ligne représentant l’élément à précontraindre. Il est essentiel que cette ligne soit en tout point identique à celle utilisée pour créer l’élément.

- P : L’intensité de la précontrainte en [𝑘𝑘𝑘𝑘]. La précontrainte de compression est considérée comme un nombre négatif tandis que la prétension est considérée comme un nombre positif.

Dans le cadre des structures de tenségrité, il est intéressant de pouvoir appliquer une précontrainte uniforme à l’ensemble des câbles ou des butons afin d’augmenter la raideur de la structure. Par exemple, prétendre les câbles avec une intensité de 2 [𝑘𝑘𝑘𝑘]. Ceci peut être fait au moyen de deux composants visibles en figure 3-24.

Composant « Prestress All Struts »

Composant « Prestress All Cables »

Figure 3-24 Composants permettant l'application de précontrainte dans l'ensemble des câbles ou dans l'ensemble des butons [Illustration de l'auteur]

L’unique paramètre d’entrée P correspond à l’intensité de la précontrainte en [𝑘𝑘𝑘𝑘]. Un nombre positif correspond à une précontrainte de compression tandis qu’un nombre négatif correspond à une prétension. Les câbles ayant été définis dans le chapitre 1.2 comme des éléments ne pouvant résister qu’à de la traction, le composant « Prestress All Cables » affichera un avertissement si le paramètre d’entrée P est un nombre négatif. À l’inverse, les butons ont été définis comme des éléments ne pouvant résister qu’à de la compression. Ainsi, le composant « Prestress All Struts » affichera un avertissement si le paramètre d’entrée P est un nombre positif.

3.5.4. Analyse Grâce aux composants présentés précédemment, la structure ainsi que les charges y étant appliquées a pu être définies. Ces structures peuvent ensuite être analysées afin de déterminer les déformations, les efforts internes ainsi que les réactions aux appuis. Cette analyse se base sur une méthode d’éléments finis non-linéaire. Avant de décrire les composants, il est nécessaire de définir brièvement en quoi correspond une analyse non linéaire. Néanmoins, ce concept sera abordé en détail dans le chapitre 4. En pratique, la plupart des structures ont un comportement que l’on peut qualifier de linéaire. C’est-à-dire que les efforts internes et les déformations sont proportionnelles aux charges appliquées. Cela signifie que si une force 𝐹𝐹 crée une déformation 𝑈𝑈, des efforts internes 𝑁𝑁 ainsi que des réactions d’appuis 𝑅𝑅, alors une force 2𝐹𝐹 créera une déformation 2𝑈𝑈, des efforts internes 2𝑁𝑁 et des réactions appuis 2𝑅𝑅.

Aucune structure n’a un comportement parfaitement linéaire. Les déformations, efforts internes engendrés par une force 𝐹𝐹 et une force 2𝐹𝐹 ne sont pas parfaitement proportionnelles. La différence est toutefois négligeable dans une majorité des cas. Cependant, certaines structures ne possèdent pas un comportement linéaire. On les qualifie de structures non-linéaires. C’est notamment le cas des structures de tenségrité qui sont instables.

L’analyse non-linéaire est donc une analyse s’effectuant en plusieurs « étapes » de manière à pouvoir mieux appréhender le comportement de la structure et notamment l’effet des déformations de cette dernière. Par opposition, une analyse linéaire s’effectue de la même manière mais en une seule « étape ». Le programme contient deux composants permettant d’analyser les structures. Le premier, « Nonlinear Solver » est un composant d’analyse non-linéaire présenté en figure 3-25. 76

Figure 3-25 Composant « Noninear Solver » [Illustration de l'auteur]

Il prend en entrée cinq paramètres : -

Struct : Il s’agit de la structure à calculer Load : Il s’agit des charges appliquées à la structure Prestress : Il s’agit de la précontrainte à appliquer à la structure. It : Il s’agit de la précision du calcul. Plus ce nombre est élevé, plus le calcul sera précis. Il sera également plus long. - Run : Il s’agit d’un interrupteur permettant de mettre en pause le composant. Afin que l’analyse l’exécute, la valeur entrée doit être True.

Une fois le composant exécuté, il renvoie six résultats : - Struct : Il s’agit de la structure analysée. Celle-ci est mise à jour afin de conserver les données concernant ses déformations et efforts internes sous une charge donnée. - U : Il s’agit d’une liste de vecteurs représentant les déplacements des nœuds en [𝑚𝑚]. - N : Il s’agit de la liste des efforts internes dans les éléments de la structure en [𝑘𝑘𝑘𝑘]. - Sigma : Il s’agit de la liste des contraintes dans chaque élément. Ces contraintes sont obtenues à partir des efforts internes et des aires des éléments. - R : Il s’agit de la liste des réactions d’appuis dans la structure en [𝑘𝑘𝑘𝑘]. - Warning : Il s’agit d’un message avertissant contenant les indices des câbles comprimés et des butons tendus. Si aucun câble n’est comprimé, ni aucune barre tendue, le composant ne renvoie pas d’avertissement. Le dernier composant, nommé « Linear Solver » et présenté en figure 3-26, permet d’analyser le calcul au moyen d’une méthode d’éléments finis linéaire.

Figure 3-26 Composant « Linear Solver » [Illustration de l'auteur]

Il comporte les mêmes paramètres d’entrée et de sortie que le composant « Nonlinear Solver » hormis l’entrée It qui n’est pas requis lors d’un calcul linéaire. L’analyse est un processus qui peut être long. Afin de ne pas perdre de données de calcul, le composant stocke les résultats obtenus. Ainsi, lorsqu’il est mis en pause, il renvoie les résultats de l’analyse réalisée afin que celle-ci soit toujours accessibles. 77

3.5.5. Optimisation L’optimisation des structures de tenségrité est un point essentiel afin d’assurer leur faisabilité. Au fil des précédents mémoires, plusieurs algorithmes et techniques d’optimisation ont été mis au point. Ces derniers sont abordés au chapitre 5 et sont utilisés par quatre composants permettant l’optimisation des structures. Le premier composant, « Optimize Prestress » présenté en figure 3-27, permet d’optimiser la précontrainte d’une structure afin de déterminer le niveau minimum nécessaire pour que l’ensemble des butons soit comprimé et que l’ensemble des câbles soit tendu. Ce niveau de précontrainte est à mettre en relation avec l’état de précontrainte de la structure qui caractérise le niveau de précontrainte des éléments de la structure les uns par rapport aux autres.

Figure 3-27 Composant « Optimize Prestress » [Illustration de l'auteur]

Le composant prend huit paramètres d’entrées : - Struct : Il s’agit de la structure à optimiser. - Loads : Il s’agit des charges sous lesquelles la structure doit être optimisée - P : Il s’agit de la précontrainte appliquée à la structure. Ce paramètre permet de définir l’état de précontrainte des éléments de la structure. - MinP : Il s’agit du niveau de précontrainte minimum dans la structure. Permettant ainsi de s’assurer d’un niveau de précontrainte minimum. - S_It : Il s’agit du paramètre It utilisé pour l’analyse non-linéaire de la structure - Opt_It : Il s’agit du nombre d’itérations maximum avant que le composant ne s’arrête. - Step : Il s’agit du pas de précontrainte entre deux itérations en [𝑘𝑘𝑘𝑘]. - Run : Il s’agit d’un interrupteur permettant de mettre en pause le composant d’optimisation. Le composant ne peut s’exécuter que si la valeur est True. Après optimisation, le composant retourne huit paramètres de sortie : - Struct : Il s’agit de la structure optimisée. Celle-ci est corrigée afin de tenir compte de l’optimisation. - P : Il s’agit de la précontrainte minimale à appliquer à la structure. - Beta : Il s’agit du niveau minimum de précontrainte à appliquer à la structure exprimée en [𝑘𝑘𝑘𝑘]. Cela correspond à l’intensité de la précontrainte la plus importante dans la structure. - U : Il s’agit d’une liste de vecteurs représentant les déplacements des nœuds en [𝑚𝑚]. - N : Il s’agit de la liste des efforts internes dans les éléments de la structure en [𝑘𝑘𝑘𝑘]. - Sigma : Il s’agit de la liste des contraintes dans chaque élément. Ces contraintes sont obtenues à partir des efforts internes et des aires des éléments. - R : Il s’agit de la liste des réactions d’appuis dans la structure en [𝑘𝑘𝑘𝑘]. - It : Il s’agit du nombre d’itérations nécessaires afin d’atteindre la convergence. 78

Les deux composants suivants permettent d’optimiser les sections des éléments pour un cas de charge et une précontrainte donnée. Le composant « Optimize Section : Full Stress » présenté en figure 3-28 permet d’optimiser une structure en utilisant une méthode dite « full stress ». Elle consiste à approcher le taux d’utilisation des sections de 1 afin que les contraintes y régnant soient les plus proches possibles de la limite élastique du matériau. Cette méthode minimise la section des éléments.

Figure 3-28 Composant « Optimize Section : Full Stress » [Illustration de l'auteur]

Le composant « Optimize Section : Group » présenté en figure 3-29 permet quant à lui d’optimiser les structures par une méthode dite « Group ». Elle consiste à utiliser la section nécessaire la plus importante pour l’ensemble de la structure afin d’obtenir des éléments de mêmes dimensions. Cela se traduit par un nombre réduit d’éléments ayant un taux d’utilisation proche ou égal à 1. Ceci signifie, comme pour le cas précédent, que ces éléments ont une contrainte proche de la limite d’élasticité du matériau.

Figure 3-29 Composant « Optimize Section : Group » [Illustration de l'auteur]

Les deux composants présentent les mêmes paramètres d’entrée : - Struct : Il s’agit de la structure à optimiser. - Loads : Il s’agit des charges sous lesquelles la structure doit être optimisée. - P : Il s’agit de la précontrainte appliquée à la structure. Ce paramètre permet de définir l’état de précontrainte des éléments de la structure. - S_It : Il s’agit du paramètre It utilisé pour l’analyse non-linéaire de la structure. - Opti_It : Il s’agit du nombre d’itérations maximum avant que le composant ne s’arrête. - Thres : Il s’agit du seuil de tolérance dans la variation des sections. Si la variation entre deux itérations est inférieure au seuil défini, l’optimisation s’arrête. - Run : Il s’agit d’un interrupteur permettant de mettre en pause le composant d’optimisation. Le composant ne peut s’exécuter que si la valeur est True. 79

Ils présentent également les mêmes paramètres de sorties : - Struct : Il s’agit de la structure optimisée. Celle-ci est corrigée afin de tenir compte de l’optimisation. - Elem : Il s’agit des éléments de la structure avec les sections corrigées. - A : Il s’agit de l’aire des différentes sections en [𝑐𝑐𝑚𝑚2 ]. - U : Il s’agit d’une liste de vecteurs représentant les déplacements des nœuds en [𝑚𝑚]. - N : Il s’agit de la liste des efforts internes dans les éléments de la structure en [𝑘𝑘𝑘𝑘]. - Sigma : Il s’agit de la liste des contraintes dans chaque élément. Ces contraintes sont obtenues à partir des efforts internes et des aires des éléments. - R : Il s’agit de la liste des réactions d’appuis dans la structure en [𝑘𝑘𝑘𝑘]. - It : Il s’agit du nombre d’itérations nécessaires afin d’atteindre la convergence.

Les composants présentés précédemment ont un défaut. En effet, aucun ne permet une optimisation complète.

L’optimisation de la précontrainte implique une variation de celle-ci. Or cela signifie également une variation des efforts internes. Celle-ci n’est pas prise en compte et peut conduire à des contraintes supérieures à la limite élastique du matériau. Une variation des sections en adéquation augmenterait le poids propre et donc le niveau de précontrainte nécessaire. Le même constat s’applique à l’optimisation des sections. La modification de ces dernières sous un cas de charge et une précontrainte définie augmente le poids propre. Or ce poids propre fait également varier le niveau de précontrainte nécessaire à l’intégrité de la structure modifiant ainsi les sections nécessaires. Ces problèmes sont moins marqués dans un modèle idéalisé où le poids propre n’est pas pris en compte. Dans ce cas de figure, les variations de sections n’ont d’impact que sur la raideur des éléments et non sur les charges appliquées à la structure. Cependant, il n’est pas possible dans le cas des structures de tenségrité de négliger leur poids propre. Ce problème est résolu par le composant « Optimize structure » présenté en figure 3-30. Celuici permet d’optimiser une structure en tenant compte de l’interaction entre section et précontrainte. La prise en compte est réalisée par des cycles successifs d’optimisation de la précontrainte et de la structure.

Figure 3-30 Composant « Optimize Structure » [Illustration de l'auteur]

Ce composant prend en entrée les mêmes paramètres que ceux présentés pour les composants d’optimisation des sections et de la précontrainte. Il renvoie également les mêmes paramètres. 80

L’optimisation des structures implique des calculs longs. A l’instar des composants d’analyse de structure, les composants d’optimisation stockent le dernier résultat obtenu. Ceci permet de mettre en pause les composants, évitant ainsi des opérations requérant un temps de calcul long tout en permettant d’utiliser les résultats de l’optimisation.

3.5.6. Résultats La catégorie résultats du programme regroupe les composants permettant d’observer et d’analyser les résultats. A ce jour, elle ne contient que quatre composants permettant de déterminer les déplacements maximums dans la structure. Le premier « Maximum Displacement », permet d’obtenir le nœud présentant le plus grand déplacement absolu.

Figure 3-31 Composant « Maximum Displacement » [Illustration de l'auteur]

Ce composant prend en entrée une structure analysée. Il renvoie par la suite deux valeurs : - u : Il s’agit de la valeur du déplacement maximum en [𝑐𝑐𝑐𝑐]. - i : Il s’agit de l’indice du nœud subissant le plus grand déplacement.

Les trois autres composants, présentés en figure 3-32, permettent de réaliser la même opération dans une direction particulière. Ils permettent ainsi d’isoler et de déterminer les déplacements verticaux, longitudinaux ou latéraux les plus importants.

Composant « Maximum Displacement X »

Composant « Maximum Displacement Y »

Composant « Maximum Displacement Z »

Figure 3-32 Composants permettant de déterminer les déplacements les plus importants selon une direction prédéfinie [Illustration de l'auteur]

3.5.7. Affichage Un des principaux avantages de l’utilisation Rhinoceros réside dans la capacité du logiciel à afficher des géométries. La catégorie affichage contient des composants interagissant avec Rhinoceros afin d’afficher les structures et d’illustrer leur comportement. Elle contient quatre composants. Le premier est le composant « Display Nodes Id » présenté en figure 3-33. Il a pour but d’afficher les indices des nœuds de manière à pouvoir les sélectionner plus facilement ou simplement pour voir où se trouve un nœud particulier dans la structure. L’affichage est présenté en figure 3-34.

Figure 3-33 Composant « Display Node Id » [Illustration de l'auteur]

L’entrée et la sortie Pt sont la liste de points à afficher permettant ainsi de placer le composant au cœur du script sans en altérer le flux. L’affichage des nœuds n’est actif que si la valeur True est entrée dans le paramètre display.

Figure 3-34 Affichage des indices des nœuds d'une passerelle de tenségrité [Illustration de l’auteur]

Le second composant, présenté en figure 3-35, s’appelle « Display structure ». Il permet d’afficher la structure dans son intégralité. Les câbles sont affichés en bleu, les butons en rouge et les barres en vert. Les supports sont, comme via le composant support, visibles sous la forme de flèches bleues montrant les directions bloquées sur les nœuds. Lorsque la structure a été analysée au moyen d’un des deux composants prévus à cet effet ou un des quatre composants d’optimisation, les informations relatives aux charges sont stockées dans la structure. Le composant permet donc également d’afficher les charges appliquées sur la structure comme le montre la figure 3-36.

Figure 3-35 Composant « Display Structure » [Illustration de l'auteur]

Le composant prend en entrée quatre paramètres : - Struct : Il s’agit de la structure à afficher. - 3D : Il s’agit d’une entrée permettant d’afficher la structure en 3D. Si la valeur est True, la structure est affichée en 3D avec ses dimensions réelles comme le montre la figure 3-37. - Nid : Il s’agit d’une entrée permettant d’afficher les indices des nœuds de la structure. Si la valeur est True, les indices des nœuds sont affichés de la même manière qu’à la figure 3-34. - Eid : Il s’agit d’une entrée permettant d’afficher les indices des éléments de la structure. Si la valeur est True, les indices des câbles sont présentés en bleu, ceux des butons en rouge et ceux des barres en vert. - Show : Il s’agit d’un paramètre permettant d’activer le composant. Le composant n’affiche la structure que si la valeur est True.

Figure 3-36 Affichage via le composant « Display Structure » d’une passerelle de tenségrité hyperstatique dont les nœuds centraux sont soumis à une charge verticale de 5 [𝑘𝑘𝑘𝑘] et les barres à une précontrainte de 200 [𝑘𝑘𝑘𝑘] [Illustration de l’auteur]

Affichage en 3D d’un nœud avec des butons carrés

Affichage en 3D d’un nœud avec des butons circulaires

Figure 3-37 Affichages en 3D de nœud de la passerelle de tenségrité [Illustration de l'auteur]

Le composant renvoie ensuite quatre valeurs : - Struct : Il s’agit de la structure affichée. Aucun changement n’y a été fait. - BC : Il s’agit de la BRep représentant les câbles. Si l’entrée 3D est False alors BC ne contient aucune donnée. - BS : Il s’agit de la BRep représentant les butons. Si l’entrée 3D est False alors BS ne contient aucune donnée. - BB: Il s’agit de la BRep représentant les barres. Si l’entrée 3D est False alors BB ne contient aucune donnée. Le troisième composant « Display Deformed », présenté en figure 3-38, permet d’afficher la structure déformée après que celle-ci ai été calculée comme le montre la figure 3-38.

Figure 3-38 Composant « Display Deformed » [Illustration de l'auteur]

Le composant prend quatre paramètres en entrées : - Struct : Il s’agit de la structure à afficher. - Scale : Il s’agit du facteur d’échelle de la déformée. - Show : Il s’agit d’un paramètre permettant d’activer le composant. Le composant n’affiche la déformée que si la valeur est True. Le composant renvoie ensuite la structure sans qu’elle ait été altérée.

Figure 3-39 Affichage de la déformée de la structure présentée en figure 3-36 via le composant « Display Deformed » avec Scale = 100 [Illustration de l’auteur]

Le dernier composant « Display Internal Forces », présenté en figure 3-40, permet d’afficher la répartition des efforts internes dans la structure grâce à un code couleur ainsi que l’affichage des valeurs sur les éléments mêmes comme le montre la figure 3-41. Les éléments tendus sont affichés en bleu tandis que les éléments comprimés sont affichés en rouge. Les éléments dont l’effort interne est nul sont affichés en blanc.

Figure 3-40 Composant « Display Internal Forces » [Illustration de l'auteur]

Le composant prend cinq paramètres en entrée : - Struct : Il s’agit de la structure à afficher. - Weight : Il s’agit d’un facteur permettant d’augmenter l’épaisseur maximum de l’affichage des efforts internes permettant de rendre plus visible les différences d’intensité des efforts internes entre les éléments. 84

- Color_prec : Il s’agit d’un facteur permettant d’augmenter la précision des couleurs. Plus la valeur est élevée, plus le dégradé de couleur est précis permettant également de rendre plus visible les différences d’intensités des efforts internes entre les éléments. - Tags : Il s’agit d’un paramètre permettant de définir l’affichage textuel des intensités des efforts internes. Si la valeur est 0, aucun effort interne n’est affiché sous forme de texte. Si la valeur est 1 l’ensemble des efforts internes seront affichés. Enfin, si la valeur est 2, seuls les efforts maximums de compression et de traction sont affichés. Il s’agit du cas de figure visible en figure 3-41. - Show: Il s’agit d’un paramètre permettant d’activer le composant. Le composant n’affiche les efforts internes que si la valeur est True.

Figure 3-41 Affichage des efforts internes dans la structure représentée à la via le composant «Display Internal Forces » [Illustration de l'auteur]

3.5.8. Outils La catégorie « Outils » propose quatre composants ne rentrant pas dans les catégories évoquées précédemment. Les deux premiers composants sont « Clear Viewport » et « Restart Proxy » ils permettent, comme leurs noms l’indique, de respectivement réinitialiser l’affichage de Rhinoceros et de redémarrer le proxy mit en place grâce à COMPAS pour réaliser les calculs scientifiques.

Figure 3-42 Composant « Clear Viewport » [Illustration de l'auteur]

Figure 3-43 Composant « Reset Proxy » [Illustration de l'auteur]

Ils sont en pratique que utiles lors d’une utilisation normale du programme. Néanmoins, ils permettent de corriger certains bugs d’affichage ou de calcul. Le composant « Restart Proxy » permet également, grâce à la réinitialisation, de prendre en compte les éventuelles modifications dans le code source sans devoir redémarrer Rhinoceros et Grasshopper. Le troisième composant « Export Structure », présenté à la figure 3-44, permet d’exporter l’ensemble des caractéristiques de la structure dans un fichier texte afin de pouvoir réaliser un posttraitement externe à Grasshopper.

Figure 3-44 Composant « Export Structure » [Illustration de l'auteur]

Le composant prend trois paramètres en entrée : - Struct : Il s’agit de la structure à exporter. - File : Il s’agit de l’emplacement du fichier dans lequel la structure doit être sauvegardée. - Run : Il s’agit d’un interrupteur permettant de mettre sur pause le composant. Ce dernier ne peut s’exécuter que si la valeur est True. Le dernier composant « Slider Variation », présenté en figure 3-45, permet de faire varier la valeur d’un slider afin d’en déterminer l’effet sur un paramètre défini. Les résultats obtenus sont ensuite écrits dans un fichier.

Figure 3-45 Composant « Slider Variation » [Illustration de l'auteur]

Le composant prend huit paramètres en entrée : - Variable : Il s’agit du slider qui verra sa valeur modifiée. - VarNam : Il s’agit du nom de la variable qui sera affichée dans le fichier contenant les résultats. - VarMax : Il s’agit de la valeur maximum que le slider prendra avant que l’opération s’arrête. Il est important de noter que la valeur de départ du slider sera sa valeur minimum et que si VarMax est supérieur à la valeur maximum du slider alors l’opération s’arrêtera après avoir atteint la valeur maximum du slider. - Step : Il s’agit du pas de variation du slider. - Result : Il s’agit du résultat à écrire dans le fichier. - ResName : Il s’agit du nom du résultat qui sera affiché dans le fichier. - File : Il s’agit de l’emplacement du fichier dans lequel la structure doit être sauvegardée. - Run : Il s’agit d’un interrupteur permettant de mettre sur pause le composant. Ce dernier ne peut s’exécuter que si la valeur est True. Cette méthode a été utilisée afin de créer les graphes montrant la relation entre l’angle de rotation relative entre les bases et le rapport de longueur des câbles et des butons 𝑟𝑟 présenté au chapitre 1.3 Dans ce cas de figure, l’entrée Variable était reliée au slider définissant l’angle tandis que l’entrée Result recevait le rapport 𝑟𝑟. 86

3.5.9. Paramètres La dernière catégorie contient les paramètres présentés en figure 3-46. Ces composants ont pour unique fonction de stocker des informations. Ils permettent de structurer le script Grasshopper. Les paramètres sont au nombre de huit et correspondent aux données pouvant être créées avec les composants présentés précédemment. La seule exception est le paramètre « Element » qui peut stocker des câbles, des butons ou des barres.

Paramètre « Cable »

Paramètre « Material »

Paramètre « Strut »

Paramètre « Bar »

Paramètre « Element »

Paramètre « Cross Section »

Paramètre « Support »

Paramètre « Structure »

Paramètre « Load »

Paramètre « Prestress »

Figure 3-46 Différents composants de la catégories paramètres [Illustration de l’auteur]

4. Calcul des structures de tenségrité Ce chapitre a pour but de décrire la méthode d’éléments finis non-linéaire utilisée par le programme. La description commence par présenter la méthode d’éléments finis linéaire utilisée par Alexy Bastien et Quentin Gravy dans leur mémoire [33]. Cette méthode permet de définir les fondements de la méthode de calcul. Ensuite, le chapitre définit la notion de non-linéarité et développe ensuite la méthode des éléments finis non-linéaire afin de répondre aux nécessités de calcul des structures non-linéaires.

4.1. Non-linéarité des structures de tenségrité 4.1.1. Non-linéarité Il existe deux sources de non-linéarité : la non-linéarité matérielle et la non-linéarité géométrique. La non-linéarité matérielle est liée au comportement du matériau. Une hypothèse communément admise est le comportement linéaire d’un matériau lors de sa phase élastique. Celle-ci se traduit par la loi de Hooke : 𝜎𝜎 = 𝜀𝜀𝜀𝜀

Bien que cette hypothèse ne soit pas exacte, elle est très proche du comportement réel de la plupart des matériaux et donc suffisante pour des applications pratiques. Toutefois, cette hypothèse n’est plus valable lorsque le seuil d’élasticité est franchi.

Figure 4-1 relation contrainte-déformation de l'acier [8]

La non-linéarité géométrique concerne quant à elle les déformations de la structure. Lorsque les déformations sont faibles, le calcul peut être réalisé au premier ordre, c’est-à-dire sur la structure non déformée. Tandis que quand celles-ci sont grandes, l’effet des charges sur la structure est altéré, comme le montre la figure 4-2, de façon importante. 88

Premier ordre

Deuxième ordre Figure 4-2 calcul au second ordre [34]

L’effet des déformations devra être évalué de manière itérative jusqu’à ce que la nouvelle déformation devienne négligeable par rapport à la précédente. Ce type d’analyse augmente drastiquement le nombre de calculs et donc le temps nécessaire pour effectuer celle-ci. Il est dès lors bien plus intéressant de réaliser un calcul linéaire, c’est-à-dire au premier ordre, quand cela est possible. Pour l’exprimer autrement, la non-linéarité invalide les hypothèses de comportement linéaire à savoir l’hypothèse de linéarité géométrique et l’hypothèse de linéarité matérielle. Ce qui implique que le principe de superposition ne peut également plus être appliqué. En effet, comme le montre la figure 4-3, la somme des déformations 𝛿𝛿𝐹𝐹1 et 𝛿𝛿𝐹𝐹2 respectivement dues à une force 𝐹𝐹1 et à la force 𝐹𝐹2 n’est pas égale à la déformation 𝛿𝛿Σ𝐹𝐹 due à la somme des forces 𝐹𝐹1 et 𝐹𝐹2 .

Figure 4-3 Principe de superposition [illustration de l'auteur]

Dans le cadre de ce mémoire, seule la non-linéarité géométrique sera prise en compte, la loi de Hooke étant supposée valide.

4.1.2. Cas des structures de tenségrité Comme évoqué dans au chapitre 1.3, les structures de tenségrité sont instables et ne peuvent être analysées de manière linéaire. L’analogie avec la structure représentée par la figure 4-4 permet de comprendre ce qui empêche le calcul au premier ordre. Celle-ci est une structure composée de deux barres rotulées simplement appuyées.

Figure 4-4 Structure non linéaire [illustration de l'auteur adaptée de [29]]

En effectuant une coupe sur la partie droite de la structure non déformée, on s’aperçoit qu’il est impossible d’obtenir l’équilibre comme le montre la figure 4-5. En effet, les efforts internes, uniquement normaux, ne peuvent pas contrebalancer la charge ponctuelle 𝐹𝐹. L’ensemble ne pouvant être équilibré, l’analyse linéaire résulte en un effort interne 𝑁𝑁 = ∞ et un déplacement 𝛿𝛿 = ∞.

Figure 4-5 Equilibre de la structure non déformée [illustration de l'auteur adaptée de [29]]

Il existe une solution. Toutefois, elle ne peut être obtenue qu’au moyen d’une analyse numérique. L’erreur résulte du manque de rigidité de la structure. Ceci implique que la matrice de rigidité est singulière ce qui rend le système d’équation insoluble. Dans le cadre de l’analyse numérique, il s’agit d’une instabilité numérique Afin de résoudre cette instabilité, il est nécessaire de réaliser un calcul au second ordre. En réalisant la même coupe que celle présentée dans la figure 4-5 sur la structure déformée, il est possible d’obtenir l’équilibre de la structure comme le montre la figure 4-6. En effet, le déplacement du nœud central change l’orientation des barres et permet à l’effort normal d’avoir une composante verticale 𝑁𝑁𝑦𝑦 .

Dans ce cas de figure, la structure ne peut pas être calculée au premier ordre, il est donc nécessaire d’effectuer un calcul au second ordre. Cependant, les déformations durant les premières itérations seront également très importantes et modifieront grandement l’intensité des efforts internes de la structure. Ainsi, le calcul au second ordre s’avère également essentiel pour évaluer le comportement de la structure. Cette méthode de résolution a fait l’objet du mémoire de Marc Eliaers [28].

Figure 4-6 Equilibre de la structure déformée [illustration de l'auteur adaptée de [29]]

4.2. Méthode linéaire d’éléments finis Ce sous-chapitre explique la méthode linéaire d’éléments finis utilisée par Alexy Bastien et Quentin Gravy [33] pour analyser les structures de tenségrité. Cette section est fortement inspirée : -

Du livre de Pierre Latteur, « calculer une structure : de la théorie à l’exemple » [34], Du cours de Jean-François Remacle « LAUCE 2125 : Finite Elements for Structures » [35], Du mémoire de Marc Eliaers « Calcul non linéaire des structures de tenségrité » [28], Du mémoire de Jonas Feron « Optimisation des structures de tenségrité sur base des indicateurs morphologiques » [29].

4.2.1. Principe La méthode linéaire d’éléments finis est une méthode permettant de calculer les déplacements des nœuds constituant la structure ainsi que les efforts internes dans chacune des barres. La méthode se base sur la résolution d’un système d’équation linéaire traduisant l’équilibre des forces en chaque nœud de la structure. Celle-ci se divise en cinq étapes : 4. 5. 6. 7. 8.

Calcul des matrices de raideur locales des éléments Assemblage de la matrice de raideur globale de la structure Application des conditions aux appuis Résolution du système d’équations Post-traitement des résultats

4.2.2. Matrices de raideurs locales des éléments Chaque élément composant la structure, câble ou barre, est traité de manière indépendante. Pour que celui-ci atteigne un état d’équilibre, les forces internes doivent compenser les forces externes. 𝐹𝐹�𝑖𝑖𝑖𝑖𝑖𝑖 = 𝐹𝐹�𝑥𝑥𝑥𝑥

Où 𝐹𝐹�𝑖𝑖𝑖𝑖𝑖𝑖 sont les forces appliquées sur les nœuds par les efforts internes dans l’élément et 𝐹𝐹�𝑒𝑒𝑒𝑒𝑒𝑒 les forces externes appliquées aux nœuds de la structure.

Dans le chapitre 1.2, nous avons posé comme hypothèse que les structures de tenségrité se comportent comme un treillis. Les efforts internes sont donc normaux : 𝐹𝐹𝑖𝑖𝑖𝑖𝑖𝑖 =

𝐸𝐸𝐸𝐸 Δ𝐿𝐿 𝐿𝐿0

Pour un élément isolé dans son repère local, les variations de longueur sont uniquement axiales : Δ𝐿𝐿 = 𝑢𝑢2𝑥𝑥 − 𝑢𝑢1𝑥𝑥 91

Figure 4-7 Elément isolé dans son repère local bidimensionnel [illustration de l’auteur]

Le vecteur des forces internes 𝐹𝐹�𝑖𝑖𝑖𝑖𝑖𝑖 s’écrit : 𝐹𝐹�𝑖𝑖𝑖𝑖𝑖𝑖

1 𝐸𝐸𝐸𝐸 0 � = 𝐿𝐿0 −1 0

0 0 0 0

𝐹𝐹1𝑋𝑋 0 𝑢𝑢1𝑋𝑋 𝑢𝑢 𝐹𝐹 0 1𝑌𝑌 �0,𝑙𝑙𝑙𝑙𝑙𝑙 𝑢𝑢�𝑙𝑙𝑙𝑙𝑙𝑙 = 𝐹𝐹�𝑒𝑒𝑒𝑒𝑒𝑒 � �𝑢𝑢 � = � 1𝑌𝑌 � = 𝐾𝐾 𝐹𝐹2𝑋𝑋 0 2𝑋𝑋 𝐹𝐹2𝑌𝑌 0 𝑢𝑢2𝑌𝑌

−1 0 1 0

Afin de décrire cet élément dans un repère global bidimensionnel, il est nécessaire de réaliser un changement de repère. Soit l’élément de la structure dont les extrémités sont les nœuds 𝑖𝑖 et 𝑗𝑗 représenté dans la figure 4-8.

Figure 4-8 Elément isolé dans le repère global bidimensionnel [illustration de l’auteur]

La matrice de changement de base 𝑇𝑇�𝑖𝑖𝑖𝑖 s’écrit alors : 𝑐𝑐𝑥𝑥 ⎡ −𝑐𝑐𝑦𝑦 𝑇𝑇�𝑖𝑖𝑖𝑖 = ⎢⎢ 0 ⎢ ⎣ 0

𝑐𝑐𝑦𝑦 𝑐𝑐𝑥𝑥 0 0

0 0 𝑐𝑐𝑥𝑥 −𝑐𝑐𝑦𝑦

0 𝑋𝑋𝑗𝑗 −𝑋𝑋𝑖𝑖 ⎤ 𝑐𝑐𝑥𝑥 = 0⎥ 𝐿𝐿 avec � 𝑌𝑌𝑗𝑗 −𝑌𝑌𝑖𝑖 𝑐𝑐𝑦𝑦 ⎥ 𝑐𝑐𝑦𝑦 = ⎥ 𝐿𝐿 𝑐𝑐𝑥𝑥 ⎦

Dans le repère global bidimensionnel, l’équation s’écrit :

𝑐𝑐 2 ⎡ 𝑥𝑥 𝐸𝐸𝐸𝐸 ⎢ 𝐿𝐿0 ⎢ ⎢ ⎣𝑠𝑠𝑠𝑠𝑠𝑠

�0,𝑙𝑙𝑙𝑙𝑙𝑙 𝑇𝑇�𝑖𝑖𝑖𝑖 𝑢𝑢�𝑙𝑙𝑙𝑙𝑙𝑙 = 𝐹𝐹�𝑒𝑒𝑒𝑒𝑒𝑒 𝑇𝑇�𝑖𝑖𝑖𝑖𝑇𝑇 𝐾𝐾

𝑐𝑐𝑥𝑥 𝑐𝑐𝑦𝑦 𝑐𝑐𝑦𝑦2

−𝑐𝑐𝑥𝑥2 −𝑐𝑐𝑥𝑥 𝑐𝑐𝑦𝑦 𝑐𝑐𝑥𝑥2

−𝑐𝑐𝑥𝑥 𝑐𝑐𝑦𝑦 𝑢𝑢 𝐹𝐹1𝑋𝑋 ⎤ 1𝑋𝑋 −𝑐𝑐𝑦𝑦2 ⎥ 𝑢𝑢1𝑌𝑌 𝐹𝐹 � � = � 1𝑌𝑌 � 𝐹𝐹2𝑋𝑋 𝑐𝑐𝑥𝑥 𝑐𝑐𝑦𝑦 ⎥ 𝑢𝑢2𝑋𝑋 ⎥ 𝑢𝑢 𝐹𝐹2𝑌𝑌 𝑐𝑐𝑦𝑦2 ⎦ 2𝑌𝑌

�0,𝑙𝑙𝑙𝑙𝑙𝑙 , 𝑢𝑢� et 𝐹𝐹� sont : Dans un repère bidimensionnel les dimensions de 𝐾𝐾 �0,𝑙𝑙𝑙𝑙𝑙𝑙 ∈ ℝ4𝑥𝑥4 𝐾𝐾

𝑢𝑢�, 𝐹𝐹� ∈ ℝ4𝑥𝑥1

Dans un repère tridimensionnel ces dimensions augmentent : 92

�0,𝑙𝑙𝑙𝑙𝑙𝑙 ∈ ℝ6𝑥𝑥6 𝐾𝐾

𝑢𝑢�, 𝐹𝐹� ∈ ℝ6𝑥𝑥1

L’équation d’équilibre s’exprime alors dans le repère local comme :

𝐹𝐹�𝑖𝑖𝑖𝑖𝑖𝑖

1 ⎡0 𝐸𝐸𝐸𝐸 ⎢ 0 ⎢ = 𝐿𝐿0 ⎢−1 ⎢0 ⎣0

0 0 0 0 0 0 0 0 0 0 0 0

𝐹𝐹1𝑋𝑋 0 0 𝑢𝑢1𝑋𝑋 ⎡ 𝐹𝐹 ⎤ ⎤ ⎡ ⎤ 𝑢𝑢 0 0 1𝑌𝑌 1𝑌𝑌 ⎥ ⎢ ⎥ ⎥⎢ 0 0⎥ ⎢ 𝑢𝑢1𝑍𝑍 ⎥ ⎢ 𝐹𝐹1𝑍𝑍 ⎥ � = = 𝐾𝐾0,𝑙𝑙𝑙𝑙𝑙𝑙 𝑢𝑢�𝑙𝑙𝑙𝑙𝑙𝑙 = 𝐹𝐹�𝑒𝑒𝑒𝑒𝑒𝑒 0 0⎥ ⎢𝑢𝑢2𝑋𝑋 ⎥ ⎢𝐹𝐹2𝑋𝑋 ⎥ 0 0⎥ ⎢𝑢𝑢2𝑌𝑌 ⎥ ⎢𝐹𝐹2𝑌𝑌 ⎥ 0 0⎦ ⎣𝑢𝑢2𝑍𝑍 ⎦ ⎣𝐹𝐹2𝑍𝑍 ⎦

−1 0 0 1 0 0

Elle s’exprime dans le repère global comme : ⎡ ⎢ ⎢ 𝐸𝐸𝐸𝐸 ⎢ 𝐿𝐿0 ⎢ ⎢ ⎢ ⎣

𝑐𝑐𝑥𝑥2

𝑐𝑐𝑥𝑥 𝑐𝑐𝑦𝑦 𝑐𝑐𝑦𝑦2 𝑠𝑠𝑠𝑠𝑠𝑠

𝑐𝑐𝑥𝑥 𝑐𝑐𝑧𝑧 𝑐𝑐𝑦𝑦 𝑐𝑐𝑧𝑧 𝑐𝑐𝑧𝑧2

−𝑐𝑐𝑥𝑥2 −𝑐𝑐𝑥𝑥 𝑐𝑐𝑦𝑦 −𝑐𝑐𝑧𝑧 𝑐𝑐𝑥𝑥 𝑐𝑐𝑥𝑥2

−𝑐𝑐𝑥𝑥 𝑐𝑐𝑦𝑦 −𝑐𝑐𝑦𝑦2 −𝑐𝑐𝑧𝑧 𝑐𝑐𝑦𝑦 𝑐𝑐𝑥𝑥 𝑐𝑐𝑦𝑦 𝑐𝑐𝑦𝑦2

−𝑐𝑐𝑥𝑥 𝑐𝑐𝑧𝑧 ⎤ 𝑋𝑋𝑗𝑗 −𝑋𝑋𝑖𝑖 −𝑐𝑐𝑦𝑦 𝑐𝑐𝑧𝑧 ⎥ 𝑢𝑢 𝐹𝐹1𝑋𝑋 1𝑋𝑋 ⎧𝑐𝑐𝑥𝑥 = 𝐿𝐿 ⎪ −𝑐𝑐𝑧𝑧2 ⎥ 𝑢𝑢1𝑌𝑌 𝐹𝐹1𝑌𝑌 𝑌𝑌𝑗𝑗 −𝑌𝑌𝑖𝑖 ⎥� � � � = avec 𝑐𝑐𝑦𝑦 = 𝑢𝑢 𝐿𝐿 𝐹𝐹 2𝑋𝑋 2𝑋𝑋 𝑐𝑐𝑥𝑥 𝑐𝑐𝑧𝑧 ⎥ ⎨ ⎪ 𝑐𝑐 = 𝑍𝑍𝑗𝑗 −𝑍𝑍𝑖𝑖 𝐹𝐹2𝑌𝑌 ⎥ 𝑢𝑢2𝑌𝑌 𝑐𝑐𝑦𝑦 𝑐𝑐𝑧𝑧 ⎥ ⎩ 𝑧𝑧 𝐿𝐿 2 ⎦ 𝑐𝑐𝑧𝑧

4.2.3. Matrice de raideur globale Les matrices locales calculées précédemment ont pour but de permettre l’assemblage de la matrice de raideur globale représentant la structure. Afin de simplifier l’explication, le système d’équations représentant un élément dont les extrémités sont les nœuds 𝑖𝑖 et 𝑗𝑗 sera réécrit sous forme de sous-matrice, chacune correspondant à l’interaction entre deux nœuds :

𝐴𝐴̅𝑖𝑖𝑖𝑖 �— ̅ 𝐴𝐴𝑗𝑗𝑗𝑗

| 𝐴𝐴̅𝑖𝑖𝑖𝑖 �𝚤𝚤 𝑢𝑢�𝚤𝚤 𝐹𝐹 + — � �𝑢𝑢� � = � � � 𝐹𝐹𝚥𝚥 𝚥𝚥 ̅ | 𝐴𝐴𝑗𝑗𝑗𝑗

L’assemblage de la matrice globale se fait également sur base de cette division sous forme de sous-matrices. Chaque sous-matrice doit être ajoutée au nœud lui correspondant dans la matrice de raideur globale.

̅ �� 𝑢𝑢� 𝐹𝐹 Σ𝐴𝐴̅ ⋯ ⋯ ⋯ ⋯ ⋯ Σ𝐴𝐴1𝑛𝑛 ⎡ 11 ⎤ ⎡ 1⎤ ⎡ 1⎤ ⋮ ⎥⎢ ⋮ ⎥ ⎢ ⋮ ⎥ ⎢ ⋮ ⋱ ⎢ ⋮ Σ𝐴𝐴̅𝑖𝑖𝑖𝑖 ⋯ Σ𝐴𝐴̅𝑖𝑖𝑖𝑖 ⋮ ⎥ ⎢ 𝑢𝑢�𝑖𝑖 ⎥ ⎢ 𝐹𝐹�𝑖𝑖 ⎥ ⎢ ⎥⎢ ⎥ ⎢ ⎥ ⋮ ⋱ ⋮ ⋮ ⎥⎢ ⋮ ⎥ = ⎢ ⋮ ⎥ ⎢ ⋮ ̅ ⋯ Σ𝐴𝐴𝑗𝑗𝑗𝑗 ̅ ⎢ ⋮ Σ𝐴𝐴𝑗𝑗𝑗𝑗 ⋮ ⎥ ⎢ 𝑢𝑢�𝑗𝑗 ⎥ ⎢ 𝐹𝐹�𝑗𝑗 ⎥ ⎢ ⎥⎢ ⎥ ⎢ ⎥ ⋱ ⋮ ⎥⎢ ⋮ ⎥ ⎢ ⋮ ⎥ ⎢ ⋮ �� 𝑢𝑢𝑛𝑛 ��⎦ 𝐹𝐹𝑛𝑛 ⎦ ⎣� Σ𝐴𝐴̅𝑛𝑛1 ⋯ ⋯ ⋯ ⋯ ⋯ Σ𝐴𝐴̅𝑛𝑛𝑛𝑛 ⎦ ⎣� ⎣�� 𝑢𝑢

�0 𝐾𝐾

𝐹𝐹�𝑒𝑒𝑒𝑒𝑒𝑒

Finalement, le système d’équations d’équilibres sur la structure devient : Où :

�0 𝑢𝑢� = 𝐹𝐹�𝑒𝑒𝑒𝑒𝑒𝑒 𝐾𝐾 93

�0 est la matrice de raideur globale de la structure, 𝐾𝐾 𝑢𝑢� est le vecteur de déplacement des nœuds, 𝐹𝐹�𝑒𝑒𝑒𝑒𝑒𝑒 est le vecteur des forces externes appliquées aux nœuds.

�0 , 𝑢𝑢� et 𝐹𝐹� , avec 𝑁𝑁 le nombre de nœuds dans Dans un repère bidimensionnel, les dimensions de 𝐾𝐾 la structure, sont : �0,𝑙𝑙𝑙𝑙𝑙𝑙 ∈ ℝ2𝑁𝑁𝑁𝑁2𝑁𝑁 𝐾𝐾

�0,𝑙𝑙𝑙𝑙𝑙𝑙 ∈ ℝ3𝑁𝑁𝑁𝑁3𝑁𝑁 𝐾𝐾

𝑑𝑑̅ , 𝐹𝐹� ∈ ℝ2𝑁𝑁𝑁𝑁1

Dans un repère tridimensionnel, ces dimensions augmentent :

𝑑𝑑̅ , 𝐹𝐹� ∈ ℝ3𝑁𝑁𝑁𝑁1

Cette équation est en fait l’expression du problème de minimisation de l’énergie potentielle de la structure. La résolution de ce système permet de déterminer la déformation minimisant l’énergie potentielle. Cette situation correspond à un état d’équilibre. Soit : -

1̅ �0 𝑢𝑢� : l’énergie élastique interne de la structure, 𝑈𝑈 = 𝑢𝑢�𝑡𝑡 𝐾𝐾 2 𝑊𝑊𝑒𝑒𝑒𝑒𝑒𝑒 = 𝑢𝑢�𝑡𝑡 𝐹𝐹�𝑒𝑒𝑥𝑥𝑡𝑡 : le travail exercé par les forces externes sur la structure, 1

�0 𝑢𝑢� − 𝑢𝑢�𝑡𝑡 𝐹𝐹�𝑒𝑒𝑒𝑒𝑒𝑒 : l’énergie potentielle totale de la structure. Π = 𝑈𝑈 − 𝑊𝑊𝑒𝑒𝑒𝑒𝑒𝑒 = 𝑢𝑢�𝑡𝑡 𝐾𝐾 2

L’équation de minimisation de la structure au regard des déformations est : 𝜕𝜕Π �0 𝑢𝑢� = 𝐹𝐹�𝑒𝑒𝑒𝑒𝑒𝑒 = 0 ⟺ 𝐾𝐾 𝜕𝜕𝑢𝑢�

4.2.4. Conditions aux appuis

Afin que le problème soit bien posé, il est nécessaire d’en définir les conditions aux limites. Ces conditions correspondent aux blocages de certains déplacements au niveau des appuis. Le problème de minimisation de l’énergie potentielle devient alors un problème de minimisation sous contraintes. Pour résoudre cette opération de minimisation, la méthode des multiplicateurs de Lagrange sera utilisée. Soit une structure soumise à 𝑀𝑀 contraintes aux appuis. On impose : Où, dans un repère tridimensionnel : -

� 𝑐𝑐̅𝑢𝑢� = 𝐷𝐷

𝑐𝑐̅ ∈ ℝ𝑀𝑀𝑀𝑀3𝑁𝑁 est la matrice des contraintes. Chaque ligne correspond à une contrainte dont la colonne du degré de liberté -un degré possible est une déformation possible d’un nœud relativement aux axes formant le repère- bloqué vaut 1, 𝑢𝑢� ∈ ℝ3𝑁𝑁𝑁𝑁1 est le vecteur des déplacements des nœuds, l’inconnue du système, � ∈ ℝ𝑀𝑀𝑀𝑀1 est le vecteur de déplacement imposé. Si l’appui est fixe, le vecteur vaut 0� . 𝐷𝐷

Le problème de minimisation est donc :

1 � �0 𝑢𝑢� − 𝑢𝑢�𝑡𝑡 𝐹𝐹�𝑒𝑒𝑒𝑒𝑒𝑒 � sous 𝑐𝑐̅𝑢𝑢� = 𝐷𝐷 min �Π = 𝑢𝑢�𝑡𝑡 𝐾𝐾 2

� = 0, le langrangien s’exprime par la En écrivant la fonction de contrainte comme 𝑔𝑔̅ = 𝑐𝑐̅𝑢𝑢� − 𝐷𝐷 fonction : 𝐿𝐿�𝑑𝑑̅ , 𝑟𝑟̅ � = Π(𝑢𝑢�) + 𝑔𝑔̅ 𝑡𝑡 (𝑢𝑢�)𝑟𝑟 ̅

⟺ 𝐿𝐿�𝑑𝑑̅ , 𝑟𝑟̅ � =

1 𝑡𝑡 �0 𝑢𝑢� − 𝑑𝑑̅ 𝑡𝑡 𝐹𝐹�𝑒𝑒𝑒𝑒𝑒𝑒 + (𝑐𝑐̅𝑢𝑢� − 𝐷𝐷 � )𝑡𝑡 𝑟𝑟̅ 𝑢𝑢� 𝐾𝐾 2

Où 𝑟𝑟̅ ∈ ℝ𝑁𝑁𝑁𝑁1 est le vecteur des multiplicateurs de Lagrange. Dans le cadre de l’optimisation de l’énergie d’une structure, ce vecteur représente les réactions aux appuis. Le problème de minimisation sous contraintes s’écrit alors : ∇𝐿𝐿�𝑑𝑑̅ , 𝑟𝑟̅ � = 0

⟺

𝜕𝜕𝜕𝜕 ⎧ =0 ⟺ ⎪𝜕𝜕𝑢𝑢�

⎨ 𝜕𝜕𝜕𝜕 ⎪ ⎩ 𝜕𝜕𝑟𝑟̅ = 0

⟺

�0 𝑢𝑢� − 𝐹𝐹�𝑒𝑒𝑒𝑒𝑒𝑒 + 𝑐𝑐̅𝑡𝑡 𝑟𝑟̅ = 0 𝐾𝐾

�=0 𝑐𝑐̅𝑢𝑢� − 𝐷𝐷

Le système de 3𝑁𝑁 + 𝑀𝑀 équations peut finalement être réécrit sous forme matricielle : � �𝐾𝐾0 𝑐𝑐̅

𝑐𝑐̅𝑡𝑡 � �𝑢𝑢�� = �𝐹𝐹�𝑒𝑒𝑒𝑒𝑒𝑒 � � 0 𝑟𝑟̅ 𝐷𝐷

La résolution de ce système permet donc d’obtenir les déformations de la structure assurant l’équilibre de celle-ci en respectant les conditions aux appuis.

4.2.5. Résolution du système d’équations La résolution du système d’effectue par inversion de la matrice : � 𝑢𝑢� � � = �𝐾𝐾0 𝑟𝑟̅ 𝑐𝑐̅

−1

𝑐𝑐̅𝑡𝑡 � 0

�

𝐹𝐹�𝑒𝑒𝑒𝑒𝑒𝑒 � 𝑑𝑑̅

Les termes du membre de droite étant connus, on obtient : -

𝑢𝑢� ∈ ℝ3𝑁𝑁𝑁𝑁1 le vecteur des déplacement des nœuds, 𝑟𝑟̅ ∈ ℝ𝑀𝑀𝑀𝑀1 le vecteur des réactions d’appuis.

4.2.6. Post-traitement des résultats

Enfin, les efforts internes dans les éléments composants la structure s’obtiennent par posttraitement des résultats. Désormais, les déplacements des nœuds sont connus. Ainsi, pour un élément dont les extrémités sont les nœuds 𝑖𝑖 et 𝑗𝑗, les efforts internes s’expriment comme :

4.2.7. Conclusion

𝑢𝑢 �0,𝑙𝑙𝑙𝑙𝑙𝑙 � 𝑖𝑖 � 𝐹𝐹�𝑖𝑖𝑖𝑖𝑖𝑖 = 𝐾𝐾 𝑢𝑢 𝑗𝑗

La méthode d’éléments finis linéaire est une méthode avantageuse. Les calculs sont simples et rapides et offrent des résultats fiables. Toutefois, pour pouvoir appliquer cette méthode et en retirer des résultats valides, il convient que la structure soit stable au premier ordre. Ce n’est malheureusement pas le cas des structures de tenségrité.

Afin de tout de même utiliser la méthode linéaire, il faut trouver une méthode pour lever l’instabilité au premier ordre. Pour ce faire, Quentin Gravy et Alexy Bastien ont utilisé un artifice de modélisation. Il s’agit de placer des éléments de faibles dimensions, n’impactant que peu la matrice de raideur, mais permettant d’ajouter un gain de raideur initial. Cet élément agit comme un appui élastique. Pour reprendre l’exemple présenté au sous-chapitre 4.1.2, la structure modifiée serait la suivante.

Figure 4-9 Approximations linéaires équivalentes d'une structure non-linéaire [illustration de l'auteur]

4.3. Méthode non-linéaire Comme décrit précédemment, l’analyse des structures de tenségrité doit être non linéaire pour deux raisons : -

La structure est soumise à de grands déplacements et nécessite donc une analyse au second ordre. La structure est instable au premier ordre et ne peut pas être calculée de manière linéaire.

Ce sous-chapitre a pour but de décrire la méthode développée par March Eliears dans son mémoire [28]. Celle-ci se base sur une approche non-linéaire et permet de modéliser de manière bien plus fidèle le comportement réel de la structure.

4.3.1. Principe La méthode non linéaire repose sur le principe d’avancement dans la solution par pas incrémentaux. Chaque pas correspond à un calcul linéaire. La charge totale 𝐹𝐹�𝑒𝑒𝑒𝑒𝑡𝑡 est divisée en incréments Δ𝐹𝐹�𝑘𝑘 . A chaque pas, la structure est soumise à un �𝑘𝑘 et les effort 𝐹𝐹�𝑘𝑘 . Celle-ci est analysée de manière linéaire afin d’obtenir les efforts internes Δ𝑁𝑁 déplacements des nœuds Δ𝑢𝑢�𝑘𝑘 . Ces efforts internes et déplacements sont intégrés à la structure de manière à obtenir une nouvelle structure. Cette nouvelle structure est utilisée comme structure de référence pour une nouvelle itération. 𝐹𝐹�𝑘𝑘+1 = 𝐹𝐹�𝑘𝑘 + Δ𝐹𝐹�𝑘𝑘

𝑢𝑢�𝑘𝑘+1 = 𝑢𝑢�𝑘𝑘 + Δ𝑢𝑢�𝑘𝑘 96

�𝑘𝑘+1 = 𝑁𝑁 �𝑘𝑘 + Δ𝑁𝑁 �𝑘𝑘 𝑁𝑁

La première itération s’effectue avec la charge 𝐹𝐹�𝑘𝑘 = Δ𝐹𝐹�1 . L’analyse se poursuit jusqu’à ce que 𝐹𝐹�𝑘𝑘+1 = 𝐹𝐹�𝑒𝑒𝑒𝑒𝑒𝑒 .

Pour l’exprimer en d’autres termes, cette méthode consiste à linéariser le problème en chaque point incrémental. Plus le nombre d’incréments 𝑛𝑛 augmente, plus la solution obtenue est proche de la solution physique. A contrario, le cas où 𝑛𝑛 = 1 correspond au cas linéaire.

Figure 4-10 Avancement dans la solution [29]

4.3.2. Matrice de raideur Les expressions développées dans ce sous-chapitre ont été démontrées par Pierre Latteur [15]. Les détails de la démonstration sont repris en annexe. La non-linéarité des structures implique que la matrice de raideur soit également non linéaire. Cette dernière est calculée à chaque itération de calcul. Elle se compose de plusieurs termes. Cependant seul deux sont pris en considération : -

�𝑒𝑒𝑒𝑒 correspondant à celle calculée dans la méthode d’éléments finis un terme élastique 𝐾𝐾 linéaire, �𝐺𝐺 tenant compte des efforts internes dans la structure un terme géométrique 𝐾𝐾 �𝑒𝑒𝑒𝑒 + 𝐾𝐾 �𝐺𝐺 �𝑙𝑙𝑙𝑙𝑙𝑙 = 𝐾𝐾 𝐾𝐾

Dans un système bidimensionnel, la matrice de raideur dans le repère global d’un élément dont les extrémités sont les nœud 𝑖𝑖 et 𝑗𝑗 s’écrit : �𝑘𝑘,𝑙𝑙𝑙𝑙𝑙𝑙 𝐾𝐾

𝑐𝑐 2 ⎡ 𝑥𝑥 𝐸𝐸𝐸𝐸 ⎢ = ⎢ 𝐿𝐿 ⎢ ⎣𝑠𝑠𝑠𝑠𝑠𝑠

𝑐𝑐𝑥𝑥 𝑐𝑐𝑦𝑦 𝑐𝑐𝑦𝑦2

−𝑐𝑐𝑥𝑥2 −𝑐𝑐𝑥𝑥 𝑐𝑐𝑦𝑦 𝑐𝑐𝑥𝑥2

−𝑐𝑐𝑥𝑥 𝑐𝑐𝑦𝑦 1 0 ⎤ −𝑐𝑐𝑦𝑦2 ⎥ 𝑁𝑁𝑘𝑘 0 1 + � ⎥ 𝐿𝐿 −1 0 𝑘𝑘 𝑐𝑐𝑥𝑥 𝑐𝑐𝑦𝑦 ⎥ 0 −1 𝑐𝑐𝑦𝑦2 ⎦

Dans le cas tridimensionnel, celle-ci s’écrit :

�𝑘𝑘,𝑙𝑙𝑙𝑙𝑙𝑙 𝐾𝐾

⎡ ⎢ 𝐸𝐸𝐸𝐸 ⎢ ⎢ = 𝐿𝐿 ⎢ ⎢ ⎢ ⎣

𝑐𝑐𝑥𝑥2

𝑐𝑐𝑥𝑥 𝑐𝑐𝑦𝑦 𝑐𝑐𝑦𝑦2 𝑠𝑠𝑠𝑠𝑠𝑠

𝑐𝑐𝑥𝑥 𝑐𝑐𝑧𝑧 𝑐𝑐𝑦𝑦 𝑐𝑐𝑧𝑧 𝑐𝑐𝑧𝑧2

−𝑐𝑐𝑥𝑥2 −𝑐𝑐𝑥𝑥 𝑐𝑐𝑦𝑦 −𝑐𝑐𝑧𝑧 𝑐𝑐𝑥𝑥 𝑐𝑐𝑥𝑥2

−𝑐𝑐𝑥𝑥 𝑐𝑐𝑦𝑦 −𝑐𝑐𝑦𝑦2 −𝑐𝑐𝑧𝑧 𝑐𝑐𝑦𝑦 𝑐𝑐𝑥𝑥 𝑐𝑐𝑦𝑦 𝑐𝑐𝑦𝑦2

−1 0 1 0

−𝑐𝑐𝑥𝑥 𝑐𝑐𝑧𝑧 ⎤ 1 −𝑐𝑐𝑦𝑦 𝑐𝑐𝑧𝑧 ⎥ ⎡ −𝑐𝑐𝑧𝑧2 ⎥ 𝑁𝑁𝑘𝑘 ⎢ ⎥+ ⎢ 𝑐𝑐𝑥𝑥 𝑐𝑐𝑧𝑧 ⎥ 𝐿𝐿𝑘𝑘 ⎢ ⎥ ⎢ 𝑐𝑐𝑦𝑦 𝑐𝑐𝑧𝑧 ⎥ ⎣ 𝑐𝑐𝑧𝑧2 ⎦

0 −1 � 0 1 0 1

𝑠𝑠𝑠𝑠𝑠𝑠

avec �

0 0 1

𝑐𝑐𝑥𝑥 =

𝑐𝑐𝑦𝑦 =

−1 0 0 1

𝑋𝑋𝑗𝑗 −𝑋𝑋𝑖𝑖 𝐿𝐿 𝑌𝑌𝑗𝑗 −𝑌𝑌𝑖𝑖

0 −1 0 0 1

𝐿𝐿

0 0⎤ ⎥ −1⎥ 0⎥ 0 ⎥ 1⎦

Avec : 𝑋𝑋𝑗𝑗 − 𝑋𝑋𝑖𝑖 ⎧𝑐𝑐𝑥𝑥 = 𝐿𝐿 ⎪ 𝑌𝑌𝑗𝑗 − 𝑌𝑌𝑖𝑖 𝑐𝑐𝑦𝑦 = 𝐿𝐿 ⎨ 𝑍𝑍𝑗𝑗 − 𝑍𝑍𝑖𝑖 ⎪ ⎩ 𝑐𝑐𝑧𝑧 = 𝐿𝐿

La méthode d’éléments finis linéaire à appliquer par la suite est la même que celle présentée au sous-chapitre 4.2. L’opération d’assemblage de la matrice globale et la prise en compte des conditions aux appuis suivent le même principe que pour celle-ci. Elle fournit les résultats d’un pas incrémental.

4.3.3. Avancement dans la solution Afin de bien comprendre la notion d’avancement dans la solution présentée au sous-chapitre 4.3.1, il est nécessaire de définir plusieurs paramètres. Premièrement, définissons le paramètre d’incrémentation adimensionnel 𝜆𝜆. Il s’agit d’un scalaire compris entre 0, la situation initiale, et 1, la situation finale où l’ensemble des charges ont été appliquées. Deuxièmement, le chargement incrémental : 𝑝𝑝̅ =

𝜕𝜕𝐹𝐹�𝑒𝑒𝑒𝑒𝑒𝑒 𝜕𝜕𝜕𝜕

Celui-ci est souvent choisi de manière indépendante à 𝜆𝜆 par facilité. Dans ce cas de figure, le chargement incrémental appliqué à chaque itération vaut le chargement total : 𝑝𝑝̅ = 𝐹𝐹𝑒𝑒𝑒𝑒𝑒𝑒

Enfin, la vélocité incrémentale 𝑣𝑣̅ correspondant au rapport entre les déplacements et le paramètre d’incrémentation : 𝑣𝑣̅ =

𝜕𝜕𝑢𝑢� 𝜕𝜕𝜕𝜕

Cette dernière s’obtient en résolvant un système d’équations faisant intervenir la matrice de �𝑘𝑘 à chaque pas 𝑘𝑘 : raideur globale 𝐾𝐾 �𝑘𝑘−1 𝑝𝑝̅ 𝑣𝑣̅ = 𝐾𝐾

Il est important de noter que dans cette expression, les conditions aux appuis n’ont pas été ajoutées afin de faciliter l’écriture. Le système total sera présenté plus loin. On remarque que lorsque 𝑝𝑝̅ = 𝐹𝐹�𝑒𝑒𝑒𝑒𝑒𝑒 , la vélocité incrémentale 𝑣𝑣̅ correspond aux déplacements dus �𝑘𝑘 . Or, la méthode non linéaire reposant à la charge externe 𝐹𝐹�𝑒𝑒𝑒𝑒𝑒𝑒 sur la structure déformée de raideur 𝐾𝐾 sur le principe d’avancement dans la solution, il est nécessaire de décomposer 𝐹𝐹�𝑒𝑒𝑒𝑒𝑒𝑒 en incréments Δ𝐹𝐹�𝑘𝑘 . Dans cette optique, le paramètre d’avancement dans la solution Δ𝜆𝜆 est défini. L’incrément de charge devient :

Δ𝐹𝐹�𝑘𝑘 = 𝑝𝑝̅ Δ𝜆𝜆 = 𝐹𝐹� Δ𝜆𝜆

�𝑘𝑘 en fonction de Δ𝜆𝜆 : Si Δ𝜆𝜆 est assez petit il est également possible d’écrire Δ𝑢𝑢�𝑘𝑘 et Δ𝑁𝑁 �𝑘𝑘 = 𝑁𝑁 �Δ𝜆𝜆 Δ𝑁𝑁

Δ𝑢𝑢�𝑘𝑘 = 𝑣𝑣̅ Δ𝜆𝜆

Il est ainsi possible de déterminer la nouvelle situation initiale à chaque étape : 98

Δ𝐹𝐹�𝑘𝑘 = 𝐹𝐹� Δ𝜆𝜆

→

𝐹𝐹�𝑘𝑘+1 = 𝐹𝐹�𝑘𝑘 + Δ𝐹𝐹�𝑘𝑘

�𝑘𝑘 = 𝑁𝑁 �Δ𝜆𝜆 Δ𝑁𝑁

→

�𝑘𝑘+1 = 𝑁𝑁 �𝑘𝑘 + Δ𝑁𝑁 �𝑘𝑘 𝑁𝑁

Δ𝑢𝑢�𝑘𝑘 = 𝑣𝑣̅ Δ𝜆𝜆

→

𝑢𝑢�𝑘𝑘+1 = 𝑢𝑢�𝑘𝑘 + Δ𝑢𝑢�𝑘𝑘

Le problème réside donc dans le choix du paramètre Δ𝜆𝜆 qui doit être assez petit pour que le point 𝑘𝑘 soit proche du point 𝑘𝑘 + 1 de telle sorte que la solution numérique converge vers la solution physique.

4.3.4. Equation de contrainte 𝚫𝚫𝝀𝝀

Dans ce sous-chapitre, nous discuterons du choix du paramètre Δ𝜆𝜆. Sa détermination est un point essentiel pour l’efficacité de l’avancement dans la solution.

Ce choix sera fait grâce à une équation de contrainte. Il existe un grand nombre d’équations de contrainte, les trois principales sont la contrainte de chargement, la contrainte de déplacement et la contrainte Arclength. Cette dernière s’avère être la plus efficace dans notre cas et sera la seule développée ici. L’ensemble des développements est disponible en annexe. Pour une longueur d’incrémentation 𝑙𝑙 contrainte Arclength est définie comme : 1

�1 + ‖𝑣𝑣̅ 2 ‖

suffisamment petite et choisie arbitrairement, la |𝑣𝑣̅ 𝑡𝑡 Δ𝑢𝑢�𝑘𝑘 + Δ𝜆𝜆| = 𝑙𝑙

L’avantage de cette méthode est qu’elle adapte la valeur de l’incrément à la raideur de la structure. Ainsi, lorsque la raideur tend vers 0, la contrainte impose ‖Δ𝑢𝑢�𝑘𝑘 ‖ = 𝑙𝑙 et minimise les déplacements. A contrario, lorsque la raideur tend vers ∞, la contrainte impose ‖Δ𝜆𝜆‖ = 𝑙𝑙. Cette méthode est donc fonctionnelle, quelle que soit la raideur de la structure contrairement aux autres méthodes évoquées. L’avancement au point 𝑘𝑘 + 1 est donc permit en résolvant le système d’équations suivant : Δ𝑢𝑢�𝑘𝑘 = 𝑣𝑣̅ Δ𝜆𝜆 1 � �1 + ‖𝑣𝑣̅ 2 ‖

⟹

|𝑣𝑣̅ 𝑡𝑡 Δ𝑢𝑢�𝑘𝑘 + Δ𝜆𝜆| = 𝑙𝑙

|Δ𝜆𝜆| =

𝑙𝑙

�1 + ‖𝑣𝑣̅ ‖2

La valeur de 𝑙𝑙 peut être choisie de manière arbitraire. Il est toutefois nécessaire de l’adapter à la structure analysée. Dans le cas d’une structure composée de simplex, la valeur 𝑙𝑙 = 0,01 a montré des résultats corrects [29]. Les résultats obtenus montrent une erreur faible et se trouvent du côté de la sécurité en surestimant les efforts internes.

4.3.5. Solveur non-linéaire Ce sous-chapitre présente les étapes de l’algorithme du solveur non linéaire présenté en Figure 4-11.

Figure 4-11 Algorithme du solveur non-linéaire [29]

4.3.5.1. Structure initiale Cette étape consiste en la définition de la géométrie, des caractéristiques mécaniques et sections des éléments ainsi que des conditions d’appuis. La définition de la géométrie de la structure est décrite en détail dans le chapitre 2. La définition des caractéristiques mécaniques, des appuis et des charges appliquées à la structure est abordée dans le chapitre 3.5.

4.3.5.2. Calcul par méthode linéaire �𝑘𝑘,𝑙𝑙𝑙𝑙𝑙𝑙 de chaque Lors de chaque itération 𝑘𝑘, il est nécessaire de définir la matrice de raideur locale 𝐾𝐾 élément composant la structure. Cette matrice est la matrice adaptée à la méthode non linéaire présentée au sous-chapitre 4.3.2. Il faut ensuite assembler celles-ci afin d’obtenir la matrice de raideur �𝑘𝑘 . La méthode d’assemblage est décrite au sous-chapitre 4.2.3. globale 𝐾𝐾 Lorsque la matrice de raideur de la structure est singulière, comme c’est le cas pour la structure présentée en Figure 4-4, le système ne peut être résolu. Celui-ci doit alors être perturbé de manière à rendre la matrice de raideur régulière. C’est notamment le cas pour les cellules prismatiques. Le simplex par exemple, ne possède aucune rigidité lorsque l’angle de rotation relatif 𝛼𝛼 = 30°. Une configuration perturbée utilisant un angle 𝛼𝛼 = 30° + 𝜀𝜀 est donc utilisée. �𝑘𝑘 assemblée et les conditions d’appuis définies, le système Une fois la matrice de raideur globale 𝐾𝐾 peut être résolu : � � �𝑣𝑣 ̅� = �𝐾𝐾𝑘𝑘 𝑟𝑟̅ 𝑐𝑐̅

−1

𝑐𝑐̅𝑡𝑡 � 0

𝑝𝑝̅ � � � 𝐷𝐷

� sont obtenus par post-traitement des résultats. Enfin, les efforts internes 𝑁𝑁

4.3.5.3. Avancement

Le paramètre d’incrémentation Δ𝜆𝜆 est ensuite calculé : |Δ𝜆𝜆| =

𝑙𝑙

�1 + ‖𝑣𝑣̅ ‖2

Ce paramètre permet d’avancer dans la solution et de s’approcher de la solution physique : Δ𝐹𝐹�𝑘𝑘 = 𝑝𝑝̅ Δ𝜆𝜆

→

𝐹𝐹�𝑘𝑘+1 = 𝐹𝐹�𝑘𝑘 + Δ𝐹𝐹�𝑘𝑘 = 𝑝𝑝̅ 𝜆𝜆𝑘𝑘+1

�𝑘𝑘 = 𝑁𝑁 �Δ𝜆𝜆 Δ𝑁𝑁

→

�𝑘𝑘+1 = 𝑁𝑁 �𝑘𝑘 + Δ𝑁𝑁 �𝑘𝑘 𝑁𝑁

Δ𝑢𝑢�𝑘𝑘 = 𝑣𝑣̅ Δ𝜆𝜆

→

𝑢𝑢�𝑘𝑘+1 = 𝑢𝑢�𝑘𝑘 + Δ𝑢𝑢�𝑘𝑘

4.3.5.4. Condition d’arrêt La condition d’arrêt principale est l’application totale des charges externes. Cela se produit lorsque : 𝜆𝜆𝑘𝑘+1 = 1

Si cette condition n’est pas atteinte, le processus réitère en considérant le point 𝑘𝑘 + 1 comme la nouvelle situation initiale.

Deux conditions supplémentaires ont été définies. La première prévient l’éventualité où 𝜆𝜆𝑘𝑘+1 > 1. La charge appliquée est alors plus importante que celle désirée. Ainsi, une condition vérifie que 𝜆𝜆𝑘𝑘+1 100

atteigne exactement 1. La deuxième condition consiste en un nombre d’itérations maximum arbitraire pour analyser la structure. Si ce nombre est dépassé, l’analyse s’arrête.

101

5. Optimisation Ce chapitre synthétise les méthodes développées dans les précédents mémoires afin d’optimiser les structures de tenségrité.

5.1. Théorie des indicateurs morphologiques Ce sous-chapitre est fortement inspiré des travaux de Pierre Latteur [34] qui a développé la théorie des indicateurs morphologiques. Celle-ci est initialement démontrée pour les structures se comportant de manière linéaire. Elle sera ensuite étendue empiriquement aux structures ayant un comportement non-linéaire et précontraintes par Jonas Feron [29]. Par la suite, lui et Pierre Latteur en démontrera rigoureusement la validité [15].

5.1.1. Structures linéaires La théorie des indicateurs morphologiques est un outil d’optimisation puissant. Celui-ci ne se limite pas aux structures de tenségrité, mais permet grâce au calcul d’une seule structure d’obtenir des résultats pouvant s’appliquer à un éventail de structures virtuellement infini dont la portée, les sections, les matériaux ou encore les charges appliquées varient. À l’origine, la porte de la théorie des indicateurs morphologiques se limitait aux structures linéaires. Toutefois, comme nous le verrons plus loin, cette théorie a été étendue aux structures nonlinéaires. Premièrement, il est essentiel de définir les paramètres caractérisant l’optimisation d’une structure : -

𝜎𝜎 : la contrainte de dimensionnement du matériau en [𝑃𝑃𝑃𝑃] 𝐿𝐿 : la portée de l’ouvrage en [𝑚𝑚] 𝐴𝐴 : l’aire d’une section en [𝑚𝑚2 ] 𝐻𝐻 : la hauteur de l’ouvrage en [𝑚𝑚] 𝐼𝐼 : l’inertie des sections en [𝑚𝑚4 ] 𝐸𝐸 : le module de Young du matériau considéré en [𝑃𝑃𝑃𝑃] 𝜇𝜇 : un nombre adimensionnel caractérisant les conditions d’extrémités d’un élément permettant de définir sa sensibilité au flambement. Dans le cas des structures de tenségrité, les nœuds sont considérés comme rotulés. Dans ce cas, 𝜇𝜇 = 1 𝜌𝜌 : le poids volumique du matériau en [𝑁𝑁⁄𝑚𝑚3 ] 𝑉𝑉 : le volume total de la structure en [𝑚𝑚3 ] 𝐹𝐹 : la charge externe totale appliquée sur la structure en [𝑁𝑁]

La longueur de cette liste de paramètres est témoin de la complexité d’un problème d’optimisation. Le nombre de paramètres étant important, la recherche d’un optimum semble une tâche ardue, voire insurmontable. Toutefois, la théorie des indicateurs morphologiques permet de réduire la complexité de ce problème en mettant en place une série de nombres adimensionnels. Ces nombres sont issus de la combinaison de ces différents paramètres et permettent de caractériser la structure. Ils sont appelés indicateurs morphologiques. On en distingue deux types : les indicateurs morphologiques primaires et les indicateurs morphologiques secondaires. 102

Les indicateurs morphologiques primaires expriment les paramètres qui auront un impact sur le résultat final de l’optimisation : -

𝐿𝐿⁄𝐻𝐻 : l’indicateur d’élancement géométrique de la structure.

𝑞𝑞 ≜

𝐼𝐼

𝐴𝐴2

: le facteur de forme, présenté dans la figure 5-1, permet de caractériser la géométrie

d’une section.

Ψ≜

𝜇𝜇𝜇𝜇𝜇𝜇

�𝑞𝑞𝑞𝑞𝑞𝑞

: l’indicateur de flambement. Il caractérise la sensibilité au flambement d’un

élément. Lorsque Ψ = 0 l’élément est insensible au flambement.

Φ≜

𝜌𝜌𝜌𝜌 𝜎𝜎

: l’indicateur de poids propre

Figure 5-1 Valeur du facteur de forme pour les sections carrées et circulaires creuses [34]

Les indicateurs morphologiques secondaires expriment les paramètres permettant la comparaison de différentes structures. Ce sont ces indicateurs qui seront optimisés : -

𝑊𝑊 ≜

𝜎𝜎𝜎𝜎 𝐹𝐹𝐹𝐹

: l’indicateur de volume de la structure

Δ ≜ 𝐸𝐸𝐸𝐸/𝜎𝜎𝜎𝜎 : l’indicateur de déplacement. Avec 𝛿𝛿 le déplacement maximal de la structure

Dans le cas des structures linéaires, il a été démontré que les indicateurs secondaires sont fonction des indicateurs primaires : 𝐿𝐿 𝑊𝑊 = 𝑓𝑓 � , Ψ, Φ� 𝐻𝐻 � 𝐿𝐿 Δ = 𝑓𝑓 � , Ψ, Φ� 𝐻𝐻

103

5.1.2. Structures non-linéaires Afin de développer la théorie des indicateurs morphologiques pour les structures non-linéaires, considérons la structure suivante calculée au second ordre :

Structure initiale

Structure au 𝑘𝑘eme ordre

Structure au premier ordre

Figure 5-2 Schémas de la structure analysée au second ordre [illustration de l'auteur adaptée de [8]]

5.1.2.1. Indicateur de déplacement Le théorème de Pasternak permet d'affirmer que le théorème de la force unité reste valable lorsque la structure soumise à l’effort unitaire est en rendu isostatique. Ainsi, on a : 𝛿𝛿𝑘𝑘 = �

𝑁𝑁𝑘𝑘 𝑛𝑛𝑘𝑘 𝑑𝑑𝑑𝑑 𝐸𝐸𝐸𝐸

Avec 𝑁𝑁𝑘𝑘 l’effort normal dans la structure hyperstatique et 𝑛𝑛𝑘𝑘 l’effort normal dû à la charge unitaire appliquée sur la structure rendue isostatique. Si on ne tient pas compte du flambement, on peut définir 𝐴𝐴 = comme : 𝛿𝛿𝑘𝑘 = 2

𝜎𝜎 𝑛𝑛 𝑙𝑙 𝐸𝐸 𝑘𝑘 𝑘𝑘 104

𝑁𝑁𝑘𝑘 𝜎𝜎

. On peut donc exprimer 𝛿𝛿𝑘𝑘

L’effort 𝑛𝑛𝑘𝑘 dû à l’effort unitaire sur la structure isostatique vaut quant à lui :

On en tire donc :

1 𝑛𝑛𝑘𝑘 = 2 sin(𝛼𝛼 )

où

�

sin(𝛼𝛼 ) =

𝐻𝐻 − 𝛿𝛿𝑘𝑘 𝑙𝑙𝑘𝑘

𝑙𝑙𝑘𝑘 = �(𝐿𝐿⁄2)2 + (𝐻𝐻 − 𝛿𝛿𝑘𝑘 )2

𝐿𝐿2 2 𝜎𝜎 4 − (𝐻𝐻 − 𝜎𝜎𝑘𝑘 ) 𝛿𝛿𝑘𝑘 = 𝐸𝐸 𝐻𝐻 − 𝛿𝛿𝑘𝑘

En mettant 𝐻𝐻 en évidence :

𝜎𝜎𝑘𝑘 2 𝐿𝐿 2 𝛿𝛿𝑘𝑘 𝜎𝜎 �2𝐻𝐻 � + �1 − 𝐻𝐻 � = 𝛿𝛿 𝐻𝐻 𝐸𝐸 1 − 𝑘𝑘 𝐻𝐻

Dans le cas d’une structure dont le comportement est linéaire on aurait pu considérer 𝛿𝛿 ≪ 𝐻𝐻 on retrouve ainsi l’indicateur de déplacement : 𝐸𝐸𝐸𝐸 1 𝐿𝐿 𝐻𝐻 𝛿𝛿 𝜎𝜎 𝐿𝐿 2 𝐿𝐿 = �� + 1 � ⇒ Δ ≜ = + = 𝑓𝑓 � � 𝜎𝜎𝜎𝜎 4 𝐻𝐻 𝐿𝐿 𝐻𝐻 𝐸𝐸 2𝐻𝐻 𝐻𝐻

Si on souhaite prendre en compte le flambement des éléments, il est nécessaire de prendre en compte Ψ : Δ≜

𝐸𝐸𝐸𝐸 𝐿𝐿 = 𝑓𝑓 � , Ψ� 𝜎𝜎𝜎𝜎 𝐻𝐻

Dans le cas d’une structure au comportement non-linéaire, on ne peut pas négliger 𝛿𝛿 ⁄𝐻𝐻 , les déformations étant trop importantes. On obtient donc : 𝛿𝛿 𝐿𝐿 𝜎𝜎 = 𝑓𝑓 � , � 𝐻𝐻 𝐻𝐻 𝐸𝐸

En tenant compte du flambement, on obtient :

𝐿𝐿 𝐿𝐿 𝐸𝐸 = 𝑓𝑓 � , � 𝛿𝛿 𝐻𝐻 𝜎𝜎

𝐸𝐸 𝐿𝐿 𝐿𝐿 = 𝑓𝑓 � , Ψ, � 𝜎𝜎 𝛿𝛿 𝐻𝐻

Il est également possible de prendre en compte le poids propre : 𝐸𝐸 𝐿𝐿 𝐿𝐿 = 𝑓𝑓 � , Ψ, , Φ� 𝜎𝜎 𝛿𝛿 𝐻𝐻

Ce développement permet de mettre en évidence deux nouveaux indicateurs morphologiques : -

𝐸𝐸� : l’indicateur morphologique primaire de raideur du matériau 𝜎𝜎 𝐿𝐿� : l’indicateur de déplacement non-linéaire. Il sera préféré à son homologue linéaire pour 𝛿𝛿 des questions de lisibilité. Il prend en compte la raideur du matériau grâce à l’indicateur morphologique de raideur du matériau.

5.1.2.2. Indicateur de volume Le volume de la structure vaut : 𝑉𝑉 = 2𝐴𝐴𝑙𝑙0 105

Si on néglige le flambement, Ψ = 0. On dimensionne alors les éléments comme : 𝐴𝐴 =

𝑁𝑁𝑘𝑘 𝐹𝐹 = 2𝜎𝜎 sin 𝛼𝛼 𝜎𝜎

La longueur initiale s’exprime quant à elle comme ;

𝐿𝐿 2 � 𝑙𝑙0 = � � + 𝐻𝐻2 2

On peut donc exprimer le volume de la structure comme :

𝑉𝑉 =

𝐿𝐿 2 𝐿𝐿 2 �� + (𝐻𝐻 − 𝛿𝛿 )2 � . �� + 𝐻𝐻2 � 𝐻𝐻 2 𝐹𝐹 𝐻𝐻 − 𝛿𝛿

𝜎𝜎

En mettant en évidence 𝐻𝐻 et en faisant apparaître 𝐿𝐿 on obtient l’indicateur de volume 𝑊𝑊 : 𝑊𝑊 ≜

𝛿𝛿 2 1 𝐿𝐿 2 1 𝐿𝐿 2 �� + �1 − � � . � � � + 1� 𝐻𝐻 4 𝐻𝐻 4 𝐻𝐻 𝐻𝐻

𝜎𝜎𝜎𝜎 = 𝐹𝐹𝐹𝐹 𝐿𝐿

1−

𝛿𝛿 𝐻𝐻

Si la structure présente un comportement linéaire, on peut considérer 𝛿𝛿 ≪ 𝐻𝐻. On obtient ainsi l’indicateur de volume linéaire : 𝑊𝑊 ≜

𝜎𝜎𝜎𝜎 1 𝐿𝐿 𝐻𝐻 𝐿𝐿 = + = 𝑓𝑓 � � 𝐹𝐹𝐹𝐹 4 𝐻𝐻 𝐿𝐿 𝐻𝐻

Dans le cas linéaire l’indicateur de déplacement Δ et l’indicateur de volume 𝑊𝑊 s’exprime donc de la même façon. Ainsi, la structure la plus légère est également la moins déformable. La prise en compte du flambement fait intervenir Ψ, on obtient : 𝑊𝑊 ≜

𝜎𝜎𝜎𝜎 𝐿𝐿 = 𝑓𝑓 � , Ψ� 𝐹𝐹𝐹𝐹 𝐻𝐻

Si la structure est non-linéaire, 𝛿𝛿 n’est plus négligeable par rapport à 𝐻𝐻. L’équation peut donc se réécrire :

Ou encore ;

𝛿𝛿 𝐿𝐿 𝑊𝑊 = 𝑓𝑓 � , Ψ, � 𝐻𝐻 𝐻𝐻 𝐸𝐸 𝐿𝐿 𝑊𝑊 = 𝑓𝑓 � , Ψ, � 𝜎𝜎 𝐻𝐻

Afin d’intégrer de manière plus formelle le poids propre de la structure, on peut également introduire l’indicateur de poids propre Φ. L’indicateur de déplacement devient alors : 𝐸𝐸 𝐿𝐿 𝑊𝑊 = 𝑓𝑓 � , Ψ, , Φ� 𝜎𝜎 𝐻𝐻

106

5.1.2.3. Indicateur de précontrainte Dans le cadre de son mémoire Jonas Feron montre que, pour des structures précontraintes différentes, mais présentant les mêmes indicateurs morphologiques primaires, les indicateurs morphologiques secondaires 𝑊𝑊 et 𝐿𝐿⁄𝛿𝛿 restent identiques tant que les niveaux de précontrainte sont calculés par la même méthode.

Il introduit également un nouvel indicateur morphologique secondaire qu’il nomme indicateur de précontrainte. Ce nouvel indicateur 𝑃𝑃⁄𝐹𝐹 représente le rapport entre la précontrainte nécessaire pour garantir l’intégrité de la structure et les forces appliquées sur celle-ci. Cet indicateur dépend des indicateurs morphologiques primaires : 𝐸𝐸 𝑃𝑃 𝐿𝐿 = 𝑓𝑓 � , Ψ, , Ψ� 𝜎𝜎 𝐹𝐹 𝐻𝐻

5.1.3. Conclusion La théorie des indicateurs morphologiques étendue aux structures non-linéaires est un outil puissant. Durant ces dernières années, Jonas Feron [29], Lindy Boucher [7] et Igor Bouckaert [8] n’ont cessé de mettre à l’épreuve celle-ci dans le cadre de leur mémoire. Au travers de ces travaux, ils ont mis en évidence des critères d’optimisation de structures composées de cellules prismatiques pour atteindre une structure optimale : 𝐸𝐸 𝑃𝑃 𝐿𝐿 ⎧min(𝑊𝑊 ) = 𝑓𝑓 � , Ψ, , Φ, � 𝜎𝜎 𝐹𝐹 𝐻𝐻 ⎪ 𝐸𝐸 𝑃𝑃 𝐿𝐿 𝐿𝐿 = 𝑓𝑓 � , Ψ, , Φ, � ≥ 500 𝜎𝜎 𝐹𝐹 𝐻𝐻 ⎨𝛿𝛿 𝐸𝐸 𝐿𝐿 ⎪ 𝑃𝑃 ⎩ 𝐹𝐹 = 𝑓𝑓 �𝐻𝐻 , Ψ, 𝜎𝜎 , Φ� < 50

Les résultats et interprétations de toutes ces optimisations présentées dans les différents mémoires confortent la position de la théorie des indicateurs morphologiques comme l’outil principal de l’optimisation des structures de tenségrité.

5.2. Optimisation de la précontrainte Il a été établi que chapitre 1.3 que lorsque les cellules prismatiques sont en état d’autocontrainte celle-ci gagne de la rigidité. Ce sont les efforts internes de la structure qui permettent ce gain. Ce fait est confirmé par l’expression de la matrice de raideur géométrique. 1 𝑁𝑁𝑘𝑘 0 �𝐺𝐺 = � 𝐾𝐾 𝐿𝐿𝑘𝑘 −1 0

0 1 0 −1

−1 0 1 0

0 −1 � 0 1

Afin d’offrir la raideur nécessaire aux structures de tenségrité pour les rendre utilisables, il s’avère nécessaire de les précontraindre. Toutefois, des niveaux de précontraintes élevés nécessitent une quantité de matière qui l’est tout autant. Ainsi, il est primordial pour la faisabilité de la structure que la précontrainte soit optimisée.

107

5.2.1. Application de la précontrainte L’application de la précontrainte fait l’objet d’un traitement particulier, présenté dans la figure 5-3, constitué de trois étapes. Tout d’abord, il est nécessaire d’externaliser la précontrainte et d’appliquer les forces équivalentes aux extrémités de l’élément précontraint. La précontrainte étant un effort normal, la direction des forces doit être parallèle à celle de l’élément précontraint. Une fois les forces externalisées, la structure est analysée sous celles-ci grâce à la méthode des �′. Ces efforts ne éléments finis non-linéaires. L’analyse nous permet d’obtenir les efforts internes 𝑁𝑁 correspondent pas à la réalité physique. En effet, l’externalisation de la précontrainte permet de déterminer l’effet de la répartition précontrainte dans l’ensemble de la structure. Elle ne permet toutefois pas de prendre en compte les efforts internes initiaux correspondant à la précontrainte. Ainsi, afin d’obtenir les efforts internes corrects il est nécessaire de prendre en compte ces efforts internes initiaux. Ceci est possible par superposition des efforts internes dus à l’externalisation de la précontrainte et ceux correspondant à la précontrainte. Dans le cas d’un élément 𝑖𝑖, soumis à une précontrainte 𝑃𝑃𝑖𝑖 l’effort interne réel vaut : 𝑁𝑁𝑖𝑖 = 𝑃𝑃 + 𝑁𝑁𝑖𝑖′

Une précontrainte de traction correspondant à des efforts externes comprimant l’élément tandis qu’une précontrainte de compression correspond quant à elle à des efforts externes tendant l’élément. En général, on observera dans l’élément un effort interne moindre que la précontrainte appliquée.

Précontrainte appliquée

Externalisation de la précontrainte

108

Effet des charges externes

Superposition des efforts internes Figure 5-3 Application de la précontrainte [illustration de l’auteur adapté de [15]]

Le phasage est également un point important. Le principe de superposition n’étant pas applicable pour les structures non-linéaires, l’ordre d’application des charges à un impact sur l’état final de la structure. La figure 5-4 présente les efforts internes finaux entre une situation pour laquelle on applique tout d’abord les charges externes et ensuite la précontrainte et une situation où on applique d’abord la précontrainte et ensuite l’ensemble des charges. Les efforts internes dans les barres sont représentés en rouge tandis que les efforts internes dans les câbles sont représentés en bleu et vert On peut observer de légères différences. Notamment pour certains câbles tendus dans une configuration et détendus dans une autre.

109

Charges externes seules

Charges externes puis précontrainte

Précontrainte seule

Précontrainte puis charge externes

Figure 5-4 Comparaison des efforts internes dans les barres, en rouge, et dans les câbles, en bleu et vert, en fonction de l'ordre d'application des charges [29]

Dans ce mémoire, le choix en fait d’appliquer tout d’abord la précontrainte et ensuite les charges externes. Ce choix est motivé par le fait que la mise en œuvre de telles structures requerrait certainement de fixer les nœuds pour pouvoir réaliser l’assemblage. Il semble donc plus simple d’appliquer la précontrainte lors de cette étape.

5.2.2. Mode d’application de la précontrainte Les différentes optimisations de structures ont permis de mettre en évidence l’importance de l’état de précontrainte des éléments. Dans le mémoire de Quentin Gravy et Alexy Bastien, l’optimisation s’effectuait en précontraignant certains câbles spécifiques. Cette méthode, efficace dans le cadre d’une analyse linéaire, s’est montrée peu efficace dans le cadre d’une analyse non-linéaire. Par la suite, deux modes d’application de la précontrainte ont été explorés en profondeur. Le premier mode d’application est la mise en tension de l’ensemble des câbles. La figure 5-5 présente les efforts internes dus à ce mode de précontrainte. Les bâtonnets rouges sont les barres, les bleus et verts sont les câbles. Tandis que les bâtonnets blancs représentent le niveau de précontrainte. On observe que la répartition de ceux-ci n’est pas idéale. En effet, certaines barres sont en traction tandis d’autre sont en compression. La même observation peut être réalisée pour les câbles. 110

Au regard de la répartition des efforts internes dus aux charges externes présentée en figure 5-6, on se rend compte que la mise en prétension ne peut pas permettre l’intégrité de la structure sans des niveaux de précontrainte aberrants.

Figure 5-5 Efforts internes dus à la mise en tension des câbles [29]

Figure 5-6 Efforts internes dus aux charges externes [29]

La précontrainte des barres, présentée en figure 5-7, offre des résultats bien plus intéressants. On observe en effet une bien meilleure répartition des efforts internes dans la structure.

111

Figure 5-7 Efforts internes dus à la précontrainte des barres [29]

Ce mode de précontrainte permet de tendre l’ensemble des câbles de manière quasi uniforme. Il n’est néanmoins pas certain que cette façon de faire soit idéale. Toutefois, cette précontrainte uniforme est une hypothèse simple présentant de bons résultats. L’intensité de la précontrainte s’avère toutefois complexe à déterminer de manière directe. Celleci fait l’objet d’une optimisation particulière.

5.2.3. Algorithmes d’optimisation de la précontrainte Trois algorithmes ont été développés : -

Un premier algorithme créé par Alexy Bastien et Quentin Gravy [33] se basant sur la méthode linéaire qu’ils ont eux-mêmes développée. Ce dernier se base sur la superposition de la précontrainte aux charges externes. La méthode linéaire ayant montré ses limites, cette méthode ne sera pas développée dans ce mémoire. Un second algorithme développé par Jonas Feron [29] se basant sur la méthode des éléments finis non-linéaire permettant l’optimisation selon un cas de charge défini. Un troisième algorithme développé par Igor Bouckaert [8] se basant également sur la méthode des éléments finis non-linéaire permettant l’optimisation selon le cas de charge le plus défavorable. Cette méthode d’optimisation a été développée dans le cadre d’une optimisation sous charge aléatoire. Cette méthode s’avérant plus difficile à mettre en œuvre au sein de Grasshopper elle a été écartée et ne sera pas développée.

Ces algorithmes permettent chacun de déterminer la précontrainte minimale permettant de parvenir à l’intégrité de la structure. Ces conditions d’intégrités sont décrites dans la définition de tenségrité proposée au chapitre 1.2 Celle-ci décrit les éléments composant la structure comme étant soit des éléments fonctionnant uniquement en compression, soit des éléments fonctionnant uniquement en traction. Ainsi la précontrainte idéale est celle assurant, sous un cas de charge donné, que l’ensemble des barres sont comprimées et que l’ensemble des câbles sont tendus, tout en maintenant le niveau de précontrainte le plus bas possible. L’algorithme proposé par Jonas Feron, illustré en figure 5-8, est celui utilisé afin de développer les composants d’optimisation. Il fonctionne par incrément. La méthode consiste en un calcul de la structure via des niveaux de contraintes croissants. Cette croissance est permise par la définition arbitraire d’un incrément de précontrainte Δ𝑃𝑃. Le niveau de précontrainte 𝑃𝑃𝑖𝑖 est donc défini comme étant : 𝑃𝑃𝑖𝑖 = 𝑖𝑖 Δ𝑃𝑃

Afin de définir la mise en précontrainte de la structure, il est important de définir deux termes : l’état de précontrainte et le scénario de précontrainte. L’état de précontrainte 𝑝𝑝̅𝑠𝑠𝑠𝑠𝑠𝑠𝑠𝑠𝑠𝑠 est un vecteur constitué de nombres adimensionnels compris dans l’intervalle [−1; 1]. Ce nombre caractérise l’intensité de la précontrainte d’un élément 𝑖𝑖 par rapport à l’ensemble de la précontrainte appliquée aux autres éléments. La précontrainte ayant l’intensité la plus importante aura donc un état de précontrainte valant 1. À l’inverse, une précontrainte nulle correspondra à un état de précontrainte valant 0. Il est également important de noter que la compression est considérée comme négative tandis que la traction est considérée comme positive.

112

Ainsi, si l'on introduit une précontrainte de compression d’une intensité 𝑃𝑃 dans l’ensemble des barres et une précontrainte de traction d’une intensité 0,5𝑃𝑃 dans l’ensemble des câbles, l’état de précontrainte sera : �� 𝑝𝑝𝑠𝑠𝑠𝑠𝑠𝑠𝑠𝑠𝑠𝑠 = [−1 −1 −1 ⋯ 0,5 0,5 0,5]𝑇𝑇

Le scénario de précontrainte 𝑃𝑃� correspond quant à lui à la précontrainte réellement appliquée à chaque élément de la structure. Il est défini comme étant le produit du niveau de précontrainte et de l’état de précontrainte. Ainsi, lors d’une itération 𝑖𝑖, le scénario de précontrainte vaut : L’algorithme comprend cinq étapes :

𝑃𝑃�𝑖𝑖 = 𝑃𝑃𝑖𝑖 𝑝𝑝̅𝑠𝑠𝑠𝑠𝑠𝑠𝑠𝑠𝑠𝑠

1. Application de la précontrainte 𝑃𝑃�𝑖𝑖 déterminée grâce au niveau de précontrainte 𝑃𝑃𝑖𝑖 et à l’état de précontrainte 𝑝𝑝̅𝑠𝑠𝑠𝑠𝑠𝑠𝑠𝑠𝑠𝑠 . 2. Analyse de la structure soumise à la précontrainte. 3. Application des charges externes sur la structure précontrainte, c’est-à-dire en état d’autocontrainte et déformée en conséquence. 4. Analyse de la structure précontrainte soumise aux charges externes. 5. Condition d’arrêt. La condition d’arrêt comme décrite précédemment consiste en la vérification du fait que l’ensemble des câbles soient tendus ainsi que l’ensemble des barres soit comprimé. Néanmoins, cette condition d’arrêt pourrait être modifiée de manière à être moins restrictive. Au sein d’une structure réelle, il est peu probable qu’un élément ne puisse résister qu’à de la compression. Ainsi, si le matériau le permet, la condition relative aux barres peut être considérée comme secondaire.

Figure 5-8 Algorithme d'optimisation de la précontrainte [illustration de l’auteur adapté de [29]]

113

5.3. Optimisation des sections Durant les précédents mémoires, deux méthodes d’optimisation ont été proposées : -

Un premier algorithme est développé par Jonas Feron [29]. Celui-ci se base sur la méthode des éléments finis non-linéaires et permet l’optimisation des sections pour un cas de charges défini. Un deuxième algorithme est développé par Igor Bouckaert [8] se basant également sur la méthode des éléments finis non-linéaires permettant l’optimisation selon le cas de charge le plus défavorable. Cette méthode d’optimisation a été développée dans le cadre d’une optimisation sous charge aléatoire. A nouveau, cette méthode est complexe à développer au sein de Grasshopper. Elle a donc été écartée et ne sera pas développée.

L’optimisation des sections a un impact important à la fois sur le plan structurel en permettant d’alléger la structure et donc d’améliorer son comportement et son efficacité, mais également sur le plan économique. Une structure plus légère étant également moins coûteuse. L’algorithme utilisé dans les composants d’optimisation des sections est celui proposé par Jonas Feron [29]. Il fonctionne, à l’instar de son algorithme d’optimisation de la précontrainte, au moyen d’un processus itératif. L’algorithme comprend trois étapes : 1. Optimisation de la précontrainte 2. Dimensionnement des éléments 3. Condition d’arrêt

Figure 5-9 Algorithme d'optimisation des sections sous charges fixes [29]

Cet algorithme laisse la liberté du choix de la méthode de dimensionnement. Bien qu’il puisse en exister d’autres, on peut distinguer trois méthodes de dimensionnement: -

Le dimensionnement uniforme qui définit l’aire de chaque élément composant la structure comme étant égale à l’aire nécessaire la plus importante. Le critère de dimensionnement est donc : 𝐴𝐴 = max(𝐴𝐴𝑖𝑖 ) Le dimensionnement group qui définit l’aire de chaque barre et câble en fonction de l’aire nécessaire plus importante des barres et câbles respectivement. Le critère de dimensionnement est donc : 𝐴𝐴𝑏𝑏𝑏𝑏𝑏𝑏𝑏𝑏𝑏𝑏 = max�𝐴𝐴𝑏𝑏𝑏𝑏𝑏𝑏𝑏𝑏𝑏𝑏,𝑖𝑖 � � 𝐴𝐴𝑐𝑐â𝑏𝑏𝑏𝑏𝑏𝑏 = max�𝐴𝐴𝑐𝑐â𝑏𝑏𝑏𝑏𝑏𝑏,𝑖𝑖 � Le dimensionnement full-stress qui définit l’aire de chaque élément comme étant celle qui lui est nécessaire.

114

Pour l’ensemble de ces dimensionnements, l’aire nécessaire est calculée avec l’hypothèse de la linéarité matérielle. Si l’on néglige le flambement, l’aire de la section de l’élément 𝑖𝑖 est : 𝐴𝐴𝑖𝑖 =

Avec : -

𝑁𝑁𝑖𝑖 𝜎𝜎𝑦𝑦

𝑁𝑁𝑖𝑖 : l’effort interne de l’élément 𝑖𝑖 𝜎𝜎y : la limite d’élasticité du matériau

L’indicateur morphologique de flambement Ψ développé par Pierre Latteur dans le cadre de sa thèse de doctorat [36] et présenté dans le sous-chapitre 5.1 permet de dimensionner un élément 𝑖𝑖 en considérant sa sensibilité au flambement : 𝐴𝐴𝑖𝑖 =

4 𝑁𝑁𝑖𝑖 �1 + �1 + 2 Ψ𝑖𝑖2 � 𝜋𝜋 2𝜎𝜎𝑦𝑦

Lorsque l’élément est insensible au flambement, comme c’est le cas pour un câble tendu, Ψ = 0. On retrouve bien : 𝐴𝐴𝑖𝑖 =

𝑁𝑁𝑖𝑖 𝜎𝜎𝑦𝑦

Lorsque l’élément est extrêmement sensible au flambement Ψ → ∞, on obtient : 𝐴𝐴𝑖𝑖 =

𝜇𝜇𝑙𝑙𝑖𝑖 𝑁𝑁𝑖𝑖 � 𝜋𝜋 𝑞𝑞𝑖𝑖 𝐸𝐸

La condition d’arrêt quant à elle se base sur un seuil de tolérance 𝜖𝜖 permettant de vérifier la convergence de l’optimisation, ce peu importe la taille des sections. Cette condition s’exprime comme : 𝐴𝐴𝑖𝑖+1 � − 1� < 𝜖𝜖 𝐴𝐴𝑖𝑖

Le choix du seuil de tolérance 𝜖𝜖 est important car il définit la précision de l’optimisation. S’il est choisi trop grand, les résultats seront imprécis. Tandis que s’il est choisi trop petit, l’opération nécessitera un très grand nombre d’itérations pour converger.

5.4. Optimisation des structures Les algorithmes d’optimisations présentés précédemment permettent d’optimiser une géométrie de structure donnée tant du point de vue de la précontrainte que du point de vue des sections. Toutefois, ces structures optimisées ne sont en réalité qu’un optimum pour une géométrie donnée. Il existe ainsi une infinité de géométries potentiellement structuralement plus efficace. Trouver une géométrie plus efficace que les autres est un problème complexe. La théorie des indicateurs morphologiques, présentée au sous-chapitre 5.1, semble être un outil adapté à la résolution de ce dernier. L’efficacité de cette théorie a d’ailleurs été prouvée au cours des derniers mémoires.

115

Cette optimisation consiste à calculer un large nombre de structures de même typologie. Cellesci peuvent ensuite être comparées afin d’obtenir un optimum selon certains critères. Ces différentes structures sont issues de variations des indicateurs morphologiques principaux. Voici par exemple les courbes des indicateurs morphologiques 𝐿𝐿⁄𝛿𝛿 et 𝑊𝑊 pour un assemblage hyperstatique composé de quatre simplex et possédant les caractéristiques suivantes : Indicateur de déplacement

Indicateur de volume

E 𝐿𝐿 𝐿𝐿 = 𝑓𝑓 � , Ψ = 0, = 900� 𝛿𝛿 𝐻𝐻 σ

𝑊𝑊 =

𝐸𝐸 𝜎𝜎𝜎𝜎 𝐿𝐿 = 𝑓𝑓 � ; Ψ = 0, = 900� 𝐹𝐹𝐹𝐹 𝐻𝐻 𝜎𝜎

Figure 5-10 Indicateurs morphologiques 𝐿𝐿⁄𝛿𝛿 et 𝑊𝑊 en fonction du rapport 𝐿𝐿⁄𝐻𝐻 pour une structure hyperstatique : 𝑛𝑛 = 4, 𝐸𝐸 ⁄𝜎𝜎 = 900, Ψ = 0 optimisées selon la méthode group [29]

On observe ainsi qu’en fixant certains indicateurs, il existe plusieurs configurations optimales : -

L’optimum de l’indicateur de déplacement 𝐿𝐿⁄𝛿𝛿 correspond à : 𝐿𝐿 𝐿𝐿 Ψ=0 ≈ 120 � � = 10 𝑊𝑊𝑜𝑜𝑜𝑜𝑜𝑜 ≈ 9 𝛿𝛿 𝑚𝑚𝑚𝑚𝑚𝑚 𝐻𝐻 𝑜𝑜𝑜𝑜𝑜𝑜 L’optimum de l’indicateur de volume 𝑊𝑊 correspond à : 𝐿𝐿 𝐿𝐿 Ψ = 0 𝑊𝑊𝑚𝑚𝑚𝑚𝑚𝑚 ≈ 6 � � =5 � � ≈ 100 𝐻𝐻 𝑜𝑜𝑜𝑜𝑜𝑜 𝛿𝛿 𝑜𝑜𝑜𝑜𝑜𝑜

Afin d’être exhaustif dans l’analyse, il est également nécessaire de faire varier les indicateurs fixés lors de l’analyse. En procédant ainsi, on obtient un grand nombre d’informations sur les structures, ces données peuvent être représentées sous la forme de courbes d’efficience. Il s’agit de courbes représentant les valeurs optimales pour une structure donnée. Voici par exemple les courbes d’efficience de la structure présentée à la figure 5-10 :

116

Indicateur de déplacement

Indicateur de volume

E 𝐿𝐿 𝐿𝐿 = 𝑓𝑓 � , Ψ = 0, = 900� 𝛿𝛿 𝐻𝐻 σ

𝑊𝑊 =

𝐸𝐸 𝜎𝜎𝜎𝜎 𝐿𝐿 = 𝑓𝑓 � ; Ψ = 0, = 900� 𝐹𝐹𝐹𝐹 𝐻𝐻 𝜎𝜎

Figure 5-11 Courbes d’efficience 𝐿𝐿⁄𝛿𝛿 et 𝑊𝑊 en fonction de Ψ pour les structures hyperstatiques : 𝑛𝑛 = 4, 𝐸𝐸 ⁄𝜎𝜎 = 900 optimisées selon la méthode group [29]

L’analyse de ces courbes nous permet ainsi de mettre en évidence que les courbes des indicateurs 𝐿𝐿⁄𝛿𝛿 et 𝑊𝑊 optimaux sont les mêmes pour Ψ > 10. Ainsi, on se rend compte que les structures les moins déformables sont également les plus légères. Ces structures correspondent à un rapport 𝐿𝐿⁄𝐻𝐻 compris entre 7 et 9.

117

6. Exemple d’utilisation du programme Ce chapitre présente une utilisation simple du logiciel et montre comment ce programme accompagne le design d’une structure et aide à la compréhension de celle-ci grâce à la possibilité d’interaction avec les paramètres.

6.1. Modélisation de la structure La structure que l’on souhaite analyser s’inspire de la Needle Tower imaginée par Kenneth Snelson. Celle-ci, bien que plus petite que sa sœur la Needle Tower II, culmine à 18[𝑚𝑚] de haut.

Figure 6-1 Needle Tower [37]

Cette structure présente quelques spécificités qui n’ont pas été prévues dans les définitions paramétriques des structures de tenségrité. Cependant, on peut obtenir un résultat très similaire grâce aux paramètres. La configuration des paramètres ainsi que la géométrie résultante est présentée en figure 6-2.

118

Paramètres

Géométrie

119

Figure 6-2 Paramètres et géométrie résultante [Illustration de l'auteur]

Pour la suite, la géométrie sera stockée de manière persistante afin de faciliter les captures d’écrans. À partir de cette géométrie, on va assembler la structure. Tout d’abord, on va définir les éléments composant la structure à savoir les câbles et les barres. Les caractéristiques des éléments, choisies arbitrairement, sont : Barres Câble

Forme Circulaire Circulaire

Diamètre 10 [𝑐𝑐𝑐𝑐] 1 [𝑐𝑐𝑐𝑐]

Épaisseur 1 [𝑐𝑐𝑐𝑐] 0,5 [𝑐𝑐𝑐𝑐]

Tableau 6-1 Caractéristiques des éléments

Matériau Acier S235 Acier S235

On va également vouloir déterminer les conditions aux appuis. Seuls trois nœuds sont au niveau du sol. On va ainsi les utiliser afin de créer deux appuis bloquant la translation dans toutes les directions ainsi qu’un appui bloquant la translation selon l’axe Z. L’assemblage se fait ensuite aisément. La définition de cette structure est disponible en figure 6-3.

Figure 6-3 Définition paramétrique de la structure dans Grasshopper [Illustration de l'auteur]

120

La structure non chargée peut désormais être affichée grâce au composant « Display Structure ». La structure affichée dans Grasshopper est présentée à la figure 6-4.

Figure 6-4 Mât de tenségrité créé grâce au composant « Display Structure » [Illustration de l'auteur]

6.2. Modélisation des charges Hormis le poids propre de la structure, la seule charge notable est la poussée latérale du vent. Afin de modéliser ces charges de vent, on crée une charge nodale sur chaque nœud. Cette charge peut être créée à partir du composant « Load X » avec, toujours arbitrairement, une intensité de 0,5 [𝑘𝑘𝑘𝑘].La définition paramétrique des charges de vent est présentée en figure 6-5.

121

Figure 6-5 Définition paramétrique des charges de vent [Illustration de l'auteur]

La structure étudiée est donc la suivante :

122

Figure 6-6 Schéma statique de la structure créé grâce au composant « Display Structure »[Illustration de l'auteur]

6.3. Calcul et comportement Si la structure est calculée telle quelle, un avertissement apparait. La figure 6-7 montre l’avertissement celui-ci met notamment en évidence que certains câbles sont comprimés. Ceci implique que le résultat est incorrect, car physiquement impossible.

123

Figure 6-7 Avertissement après le calcul d'une structure [Illustration de l'auteur]

Afin de corriger ce problème, il est nécessaire de précontraindre la structure. Il a été établi dans le chapitre 5.2 que pour une passerelle de tenségrité la précontrainte uniforme des barres offre les meilleurs résultats. Grâce au composant « Prestress All Struts » nous allons pouvoir précontraindre l’ensemble des barres. Malheureusement, comme le montre la figure 6-8 même avec des niveaux de précontrainte importants, la structure voit toujours certains de ces câbles comprimés.

Figure 6-8 Avertissement après le calcul de la structure dont les barres sont précontraintes [Illustration de l'auteur]

Néanmoins, comme le montre la figure 6-9, en essayant de nouvelles combinaisons avec le programme on se rend compte que précontraindre différemment offre de bien meilleurs résultats. Ici, en appliquant une précontrainte 𝑃𝑃 aux barres et environ 40% de cette valeur aux câbles, on peut drastiquement diminuer l’intensité nécessaire tout en améliorant le comportement de la structure.

Figure 6-9 Résultat pour un scénario de précontrainte alternatif [Illustration de l'auteur]

Cet exemple est une bonne illustration de la puissance du programme : jouer pour designer. On peut ensuite observer la déformée grâce au composant « Display Deformed ».

124

Figure 6-10 Déformée de la structure créée grâce au composant « Display Deformed » et un facteur d’échelle 2 [Illustration de l'auteur]

6.4. Optimisation L’optimisation de la structure grâce au composant « Optimize Structure » permet de diminuer drastiquement les aires des sections ainsi que le niveau de précontrainte. Il n’est désormais plus nécessaire que d’avoir 100 [𝑘𝑘𝑘𝑘] de précontrainte dans les barres et 37,5 [𝑘𝑘𝑘𝑘] dans les câbles.

La déformée présentée figure 6-11 en est également très différente. Le tassement vertical de la structure est bien plus présent que précédemment. Cette différence peut s’expliquer par le fait que les grandes déformations font participer le poids propre aux déformations latérales. Or, comme les sections sont moins importantes après optimisation cet effet s’en retrouve amoindri. Il semble évident que les déformations sont bien trop grandes pour assurer la faisabilité d’un tel ouvrage. Cependant, ce chapitre à un objectif illustratif. Ainsi, l’optimisation ne sera pas menée à son terme.

125

Figure 6-11 Déformée de la structure après optimisation créée grâce au composant « Display Deformed » et un facteur d’échelle 2 [Illustration de l’auteur]

6.5. Variations La définition paramétrique de la structure offre un avantage majeur. Le calcul de la structure étant également paramétrique, un simple changement dans les paramètres de la définition géométrique permet d’observer le comportement de la nouvelle structure. C’est par exemple le cas dans la figure pour un changement de type de rotation passant d’alternée à continue.

126

Figure 6-12 Déformation avant optimisation pour la même structure dont la rotation serait continue [Illustration de l'auteur]

127

7. Conclusion et perspectives Les structures de tenségrité sont complexes du point de vue du comportement et de l’analyse. Elles sont également géométriquement complexes. Lors des précédents mémoires, un travail très important a été réalisé sur le vaste sujet de la tenségrité. Cependant, les outils utilisés n’étaient pas toujours adaptés. C’est principalement le cas de la définition de la géométrie. En effet, les méthodes développées avec les langages de programmation limitaient fortement la liberté de design. L’utilisation de Grasshopper a permis d’exalter les possibilités de création de géométries de tenségrité tout en en réduisant la complexité. Les outils géométriques développés ont ainsi permis de générer de nouvelles typologies, mais également, et surtout, de redécouvrir celles ayant déjà été étudiées lors des précédents travaux. D’autres outils utilisés étaient, à contrario, bien plus adaptés que ce qu’il est possible de faire au sein de Grasshopper. C’est principalement le cas des outils de calculs dont le développement dans l’interface Grasshopper s’est avéré problématique. Néanmoins, la solution choisie permet d’utiliser au mieux les avantages de chacun des outils. L’utilisation de COMPAS permet de scinder le fonctionnement du programme en deux parties distinctes. La première a pour fonction l’interface utilisateur et le prétraitement des données. Cette partie est propre à l’interface Grasshopper et possède ses propres règles et conventions. L’autre partie permet de réaliser les calculs et le post-traitement. Cette partie est totalement indépendante de la première et peut ainsi être facilement modifiée sans qu’il soit nécessaire de corriger les outils propres à Grasshopper. Cette séparation permettra de doter ce programme de nouvelles fonctionnalités étendant encore les capacités du programme. À l’issue de cette année de travail, j’ai acquis de nombreuses compétences et connaissances en design paramétrique. Je suis désormais fier de pouvoir offrir aux prochains mémorants ainsi qu’à quiconque le souhaiterait un programme permettant d’explorer la tenségrité comme il n’en existe pas d’autre. Je suis persuadé que l’approche paramétrique promue dans ce mémoire permettra d’aborder le design des structures de tenségrité avec un œil neuf et ainsi d’arpenter des sentiers encore inexplorés.

128

Table des illustrations Figure 1-1 Richard Buckminster Fuller, inventeur de la tenségrité [3] .................................................. 4 Figure 1-2 Study in balance [4] ................................................................................................................ 5 Figure 1-3 X-Piece [5] .............................................................................................................................. 5 Figure 1-4 Tore hélicoïdal [6] .................................................................................................................. 5 Figure 1-5 Cellule octaédrique présentant des barres dans son enveloppe [illustration de l’auteur] ... 7 Figure 1-6 Assemblage dont plusieurs barres se touchent [illustration de l’auteur].............................. 7 Figure 1-7 Simplex [illustration de l'auteur] ............................................................................................ 8 Figure 1-8 Schéma de fabrication d'un simplex régulier [illustration de l'auteur] ................................. 8 Figure 1-9 Vue d'une face d'un simplex régulier ..................................................................................... 8 Figure 1-10 Variation de l'angle de rotation d'un simplex régulier [illustration de l’auteur inspirée de [8]] ........................................................................................................................................................... 9 Figure 1-11 - Schéma de frabrication d'un quadruplex régulier [illustration de l'auteur] .................... 10 Figure 1-12 Variation de l'angle de rotation d'un quadruplex régulier [illustration de l’auteur] ......... 10 Figure 1-13 Schéma de fabrication d'un pentaplex régulier [illustration de l’auteur].......................... 11 Figure 1-14 Variation de l'angle de rotation d'un pentaplex régulier [illustration de l’auteur] ........... 11 Figure 1-15 Comparaison des rapports 𝑟𝑟 en fonction des angles de rotations pour des cellules régulières [illustration de l’auteur] ........................................................................................................................ 12 Figure 1-16 Simplex de différentes hauteurs tous stables pour [Illustration de l'auteur] .................... 12 Figure 1-17 Schéma de fabrication d'un assemblage nœud sur nœud de deux simplex [illustration de l'auteur] ................................................................................................................................................. 13 Figure 1-18 Schéma de fabrication d'un assemblage nœud sur câble de deux simplex [illustration de l'auteur] ................................................................................................................................................. 14 Figure 1-19 Tore hélicoïdal [6] .............................................................................................................. 14 Figure 1-20 Assemblage unidimensionnel nœud sur nœud [illustration de l'auteur] .......................... 15 Figure 1-21 Assemblage unidimensionnel nœud sur câble [illustration de l'auteur] ........................... 15 Figure 1-22 Type de jonctions [11] ........................................................................................................ 15 Figure 1-23 Jonctions de six simplex ..................................................................................................... 15

129

Figure 1-24 Vue axonométrique d'un assemblage bidimensionnel nœud sur nœud [1] ..................... 16 Figure 1-25 Easy Landing [12]................................................................................................................ 17 Figure 1-26 Needle Tower II [13] ........................................................................................................... 17 Figure 1-27 Contour Coffee Table [14] .................................................................................................. 18 Figure 1-28 Muscle 3 [14] ...................................................................................................................... 18 Figure 1-29 Kurilpa Bridge [16].............................................................................................................. 18 Figure 1-30 Tensegrity Bridge [17] ........................................................................................................ 19 Figure 1-31 Ninety Nine Failures - Vue intérieure [18] ......................................................................... 19 Figure 1-32 Ninety Nine Faillures - Vue extérieure [18] ........................................................................ 19 Figure 2-1 Simplex régulier [illustration de l'auteur] ............................................................................ 20 Figure 2-2 Encodage d'un simplex régulier ........................................................................................... 21 Figure 2-3 Paramètres principaux régissant la géométrie d'un simplex [Illustration de l'auteur]........ 21 Figure 2-4 Définition paramétrique d'un simplex via le logiciel Grasshopper [illustration de l'auteur]22 Figure 2-5 Visualisation du simplex dans Rhinoceros [illustration de l'auteur] .................................... 22 Figure 2-6 Composant « Ellipse » [Illustration de l’auteur]................................................................... 23 Figure 2-7 Description du composant « Ellipse » et d'un de ses paramètres d'entrée [Illustration de l’auteur] ................................................................................................................................................. 23 Figure 2-8 Script créant un prisme par extrusion [Illustration de l'auteur] .......................................... 23 Figure 2-9 Résultats de différentes configurations du script [Illustration de l'auteur] ......................... 24 Figure 2-10 Points 3D et 2D [19] ........................................................................................................... 25 Figure 2-11 Représentation des types primitifs des courbes [19] ........................................................ 25 Figure 2-12 Comparaison de l'évaluation d’un point dans le repère 3D et le repère de la surface [19] ............................................................................................................................................................... 26 Figure 2-13 Comparaison de mesh à leur surface de référence [Illustration de l'auteur] .................... 26 Figure 2-14 Etat du composant après définitions des données [19] .................................................... 26 Figure 2-15 Sauvegarde des données volatiles [19] .............................................................................. 27 Figure 2-16 Interaction des listes [Illustration de l’auteur]................................................................... 27 Figure 2-17 Structure d'une arborescence [19] .................................................................................... 28

130

Figure 2-18 Comparaison entre liste et arborescence [19] ................................................................... 28 Figure 2-19 Comparaison des fils représentant les listes et les arborescences [Illustration de l'auteur] ............................................................................................................................................................... 29 Figure 2-20 Simulation d'un simplex [illustration de l’auteur] .............................................................. 30 Figure 2-21 Résultat de la simulation d'un simplex [illustration de l’auteur] ....................................... 30 Figure 2-22 Génomes (en rose) et fitness (en vert) [illustration de l'auteur] ....................................... 31 Figure 2-23 Fitness landscape [22] ........................................................................................................ 31 Figure 2-24 Représentation du processus d'optimisation [22] ............................................................. 32 Figure 2-25 Variables (en rose) et objectifs (en vert) [illustration de l'auteur] .................................... 32 Figure 2-26 Composant « Polygon » [illustration de l'auteur] .............................................................. 36 Figure 2-27 Vues en plan et en perspective d'une rotation continue [illustration de l'auteur] ........... 36 Figure 2-28 Vues en plan et en perspective d'une rotation alternée [illustration de l'auteur] ............ 37 Figure 2-29 Utilisation du composant graph mapper afin d'obtenir les facteurs de mise à l'échelle [Illustration de l'auteur] ........................................................................................................................ 37 Figure 2-30 Assemblage correspondant à la figure 2-29 [Illustration de l'auteur] ............................... 37 Figure 2-31 Effet de la transposition de l'arborescence [Illustration de l'auteur] ................................ 38 Figure 2-32 Passage d'un mode d'assemblage nœud sur nœud à nœud sur câble [Illustration de l'auteur] ................................................................................................................................................. 39 Figure 2-33 Comparaison des plans de construction entre un assemblage courbe et un assemblage rectiligne [Illustration de l'auteur] ........................................................................................................ 42 Figure 2-34 Suppression des câbles et barres surnuméraires [Illustration de l'auteur] ....................... 43 Figure 2-35 Composant « Square » [Illustration de l'auteur] ................................................................ 46 Figure 2-36 Vues en plan et en perspective des grilles [Illustration de l'auteur].................................. 46 Figure 2-37 Liaison des carrés de la grille et de la diagrid [Illustration de l'auteur] ............................. 47 Figure 2-38 Vue en élévation d'assemblages ayant un nombre différent de nappes [Illustration de l'auteur] ................................................................................................................................................. 47 Figure 2-39 Création des cercles [Illustration de l’auteur] .................................................................... 53 Figure 2-40 Création des nœuds [Illustration de l'auteur] .................................................................... 53 Figure 2-41 Création des câbles formant les cercles [Illustration de l'auteur[ ..................................... 54 Figure 2-42 Schéma d'assemblage d'un anneau [Illustration de l'auteur] ............................................ 54 131

Figure 2-43 Création des câbles et barres [Illustration de l'auteur] ..................................................... 54 Figure 2-44 Géométrie finale par superpositions des géométries calculées [Illustration de l'auteur]. 54 Figure 2-45 Barres [Illustration de l'auteur] .......................................................................................... 57 Figure 2-46 Câbles des faces [Illustration de l'auteur] .......................................................................... 57 Figure 2-47 Câbles des arêtes [Illustration de l'auteur] ........................................................................ 58 Figure 2-48 Géométrie finale obtenue par superposition [Illustration de l'auteur] ............................. 58 Figure 2-49 Structure de tenségrité obtenue à partir du lapin de Stanford [26] .................................. 59 Figure 2-50 Création de la topologie d'un tétraèdre régulier en une structure de tenségrité icosaédrique régulière pour un angle 𝜃𝜃 = 45° [26].............................................................................. 59 Figure 3-1 Composants « VB Script », « C# Script » et « GhPython Script » [Illustration de l'auteur].. 61

Figure 3-2 Interface de programmation du composant « GhPython Script » [Illustration de l'auteur] 62 Figure 3-3 Création d'une matrice aléatoire utilisant NumPy [Illustration de l’auteur] ....................... 63 Figure 3-4 Comparaison d'un script permettant d'obtenir les extrémités d'une ligne avec GH_CPython et GhPython [Illustration de l'auteur] ................................................................................................... 63 Figure 3-5 Création d'une matrice identité en utilisant NumPy grâce à GH Python Remote [Illustration de l'auteur] ............................................................................................................................................ 64 Figure 3-6 Interface Grasshopper avec la fenêtre GH Python Remote [Illustration de l'auteur] ......... 65 Figure 3-7 Représentation du fonctionnement d'un proxy [Illustration de l'auteur] ........................... 66 Figure 3-8 Structure du logiciel [Illustration de l'auteur] ...................................................................... 67 Figure 3-9 Script de création des assemblages bidimensionnels plans et cluster équivalent [Illustration de l'auteur] ............................................................................................................................................ 70 Figure 3-10 Composant « Structure » [Illustration de l'auteur] ............................................................ 70 Figure 3-11 Composants permettant la création des sables, butons et câbles [Illustration de l'auteur] ............................................................................................................................................................... 71 Figure 3-12 Composant « Circular Cross Section » et « Square Cross Section » [Illustration de l'auteur] ............................................................................................................................................................... 71 Figure 3-13 Composant « Create Material » [Illustration de l'auteur].................................................. 71 Figure 3-14 Composant « Material List » [Illustration de l'auteur] ....................................................... 72 Figure 3-15 Composant « Support » [Illustration de l'auteur] .............................................................. 72 Figure 3-16 Affichage des appuis pour une passerelle de tenségrité dont les nœuds extrêmes sont simplement appuyés [Illustration de l’auteur] ...................................................................................... 73 132

Figure 3-17 Composants « Support X », « Support Y » et « Support Z » [Illustration de l'auteur] ....... 73 Figure 3-18 Composants permettant de récupérer les caractéristiques des objets présentés précédemment [Illustration de l'auteur].............................................................................................. 73 Figure 3-19 Composant « Gravity » [Illustration de l'auteur] ............................................................... 74 Figure 3-20 Composant « Load » [Illustration de l'auteur] ................................................................... 74 Figure 3-21 Affichage des charges ponctuelles de 3kN dans la direction (1; 1; -2) appliquées sur la première moitié des nœuds d’une passerelle de tenségrité [Illustration de l’auteur] ......................... 75 Figure 3-22 Composants permettant d'appliquer une charge ponctuelle dans une direction prédéfinie [Illustration de l’auteur] ........................................................................................................................ 75 Figure 3-23 Composant « Prestress » [Illustration de l'auteur] ............................................................ 75 Figure 3-24 Composants permettant l'application de précontrainte dans l'ensemble des câbles ou dans l'ensemble des butons [Illustration de l'auteur] ................................................................................... 76 Figure 3-25 Composant « Noninear Solver » [Illustration de l'auteur] ................................................. 77 Figure 3-26 Composant « Linear Solver » [Illustration de l'auteur] ...................................................... 77 Figure 3-27 Composant « Optimize Prestress » [Illustration de l'auteur] ............................................. 78 Figure 3-28 Composant « Optimize Section : Full Stress » [Illustration de l'auteur] ............................ 79 Figure 3-29 Composant « Optimize Section : Group » [Illustration de l'auteur] .................................. 79 Figure 3-30 Composant « Optimize Structure » [Illustration de l'auteur] ............................................ 80 Figure 3-31 Composant « Maximum Displacement » [Illustration de l'auteur].................................... 81 Figure 3-32 Composants permettant de déterminer les déplacements les plus importants selon une direction prédéfinie [Illustration de l'auteur] ....................................................................................... 81 Figure 3-33 Composant « Display Node Id » [Illustration de l'auteur] .................................................. 81 Figure 3-34 Affichage des indices des nœuds d'une passerelle de tenségrité [Illustration de l’auteur] ............................................................................................................................................................... 82 Figure 3-35 Composant « Display Structure » [Illustration de l'auteur] ............................................... 82 Figure 3-36 Affichage via le composant « Display Structure » d’une passerelle de tenségrité hyperstatique dont les nœuds centraux sont soumis à une charge verticale de 5 [𝑘𝑘𝑘𝑘] et les barres à une précontrainte de 200 [𝑘𝑘𝑘𝑘] [Illustration de l’auteur] ..................................................................... 83 Figure 3-37 Affichages en 3D de nœud de la passerelle de tenségrité [Illustration de l'auteur] ......... 83

Figure 3-38 Composant « Display Deformed » [Illustration de l'auteur] .............................................. 84 Figure 3-39 Affichage de la déformée de la structure présentée en figure 3-36 via le composant « Display Deformed » avec Scale = 100 [Illustration de l’auteur] ......................................................... 84 133

Figure 3-40 Composant « Display Internal Forces » [Illustration de l'auteur] ...................................... 84 Figure 3-41 Affichage des efforts internes dans la structure représentée à la via le composant «Display Internal Forces » [Illustration de l'auteur] ............................................................................................ 85 Figure 3-42 Composant « Clear Viewport » [Illustration de l'auteur] ................................................... 85 Figure 3-43 Composant « Reset Proxy » [Illustration de l'auteur] ........................................................ 85 Figure 3-44 Composant « Export Structure » [Illustration de l'auteur] ................................................ 86 Figure 3-45 Composant « Slider Variation » [Illustration de l'auteur] .................................................. 86 Figure 3-46 Différents composants de la catégories paramètres [Illustration de l’auteur].................. 87 Figure 4-1 relation contrainte-déformation de l'acier [8] ..................................................................... 88 Figure 4-2 calcul au second ordre [34] .................................................................................................. 89 Figure 4-3 Principe de superposition [illustration de l'auteur] ............................................................. 89 Figure 4-4 Structure non linéaire [illustration de l'auteur adaptée de [29]]......................................... 90 Figure 4-5 Equilibre de la structure non déformée [illustration de l'auteur adaptée de [29]] ............. 90 Figure 4-6 Equilibre de la structure déformée [illustration de l'auteur adaptée de [29]] .................... 91 Figure 4-7 Elément isolé dans son repère local bidimensionnel [illustration de l’auteur] ................... 92 Figure 4-8 Elément isolé dans le repère global bidimensionnel [illustration de l’auteur] .................... 92 Figure 4-9 Approximations linéaires équivalentes d'une structure non-linéaire [illustration de l'auteur] ............................................................................................................................................................... 96 Figure 4-10 Avancement dans la solution [29]...................................................................................... 97 Figure 4-11 Algorithme du solveur non-linéaire [29] ............................................................................ 99 Figure 5-1 Valeur du facteur de forme pour les sections carrées et circulaires creuses [34] ............. 103 Figure 5-2 Schémas de la structure analysée au second ordre [illustration de l'auteur adaptée de [8]] ............................................................................................................................................................. 104 Figure 5-3 Application de la précontrainte [illustration de l’auteur adapté de [15]] ......................... 109 Figure 5-4 Comparaison des efforts internes dans les barres, en rouge, et dans les câbles, en bleu et vert, en fonction de l'ordre d'application des charges [29] .............................................................. 110 Figure 5-5 Efforts internes dus à la mise en tension des câbles [29] .................................................. 111 Figure 5-6 Efforts internes dus aux charges externes [29] .................................................................. 111 Figure 5-7 Efforts internes dus à la précontrainte des barres [29] ..................................................... 112

134

Figure 5-8 Algorithme d'optimisation de la précontrainte [illustration de l’auteur adapté de [29]] . 113 Figure 5-9 Algorithme d'optimisation des sections sous charges fixes [29] ....................................... 114 Figure 5-10 Indicateurs morphologiques 𝐿𝐿𝐿𝐿 et 𝑊𝑊 en fonction du rapport 𝐿𝐿𝐿𝐿 pour une structure hyperstatique : .................................................................................................................................... 116 Figure 5-11 Courbes d’efficience 𝐿𝐿𝐿𝐿 et 𝑊𝑊 en fonction de Ψ pour les structures hyperstatiques : ... 117 Figure 6-1 Needle Tower [37].............................................................................................................. 118 Figure 6-2 Paramètres et géométrie résultante [Illustration de l'auteur] .......................................... 120 Figure 6-3 Définition paramétrique de la structure dans Grasshopper [Illustration de l'auteur]....... 120 Figure 6-4 Mât de tenségrité créé grâce au composant « Display Structure » [Illustration de l'auteur] ............................................................................................................................................................. 121 Figure 6-5 Définition paramétrique des charges de vent [Illustration de l'auteur] ............................ 122 Figure 6-6 Schéma statique de la structure créé grâce au composant « Display Structure »[Illustration de l'auteur] .......................................................................................................................................... 123 Figure 6-7 Avertissement après le calcul d'une structure [Illustration de l'auteur] ........................... 124 Figure 6-8 Avertissement après le calcul de la structure dont les barres sont précontraintes [Illustration de l'auteur] .......................................................................................................................................... 124 Figure 6-9 Résultat pour un scénario de précontrainte alternatif [Illustration de l'auteur] ............... 124 Figure 6-10 Déformée de la structure créée grâce au composant « Display Deformed » et un facteur d’échelle 2 [Illustration de l'auteur] .................................................................................................... 125 Figure 6-11 Déformée de la structure après optimisation créée grâce au composant « Display Deformed » et un facteur d’échelle 2 [Illustration de l’auteur] ........................................................................... 126 Figure 6-12 Déformation avant optimisation pour la même structure dont la rotation serait continue [Illustration de l'auteur] ...................................................................................................................... 127 Figure 8-1 Schéma statique de la structure analysée [Illustration de l’auteur] ..................................... III Figure 8-2 Schéma statique du treillis hyperstatique [34] ..................................................................... IV Figure 8-3 Schéma statique d’un treillis composé de simplex 𝜃𝜃 = 0 [29] ............................................. V

Figure 8-4 Schéma statique de la structure non-linéaire [Illustration de l'auteur]................................ VI Figure 8-5 Comparaison de la solution analytique aux résultats du programme pour différentes longueurs d'incrémentation 𝑙𝑙 [Illustration de l'auteur] ........................................................................ VII

135

Références [1] R. Motro, Tensegrity Structural Systems for the Futrue, London: Kogan Page, 2003. [2] R. Buckminster Fuller, "Tensegrity" Portfolio and Art News Annual, vol. 4, 1961. [3] M. Pereira, «Tensegrity Structures: What They Are and What They Can Be,» 03 juin 2018. [En ligne]. Available: https://www.archdaily.com/893555/tensegrity-structures-what-they-are-andwhat-they-can-be. [4] S. Khan-Magomedov, «L'architecture de l'avant-garde soviétique,» [En ligne]. Available: http://www.alyoshin.ru/Files/publika/khan_archi/khan_archi_1_033.html. [5] M. Pars, «The X-module,» [En ligne]. Available: http://www.tensegriteit.nl/e-xmodule.html. [Accès le 10 04 2020]. [6] M.-A. Bayer, «David-Georges EMMERICH,,» 2002. [7] L. Boucher, «Optimisation des structures de tenségrité composées de modules prismatiques,» Ecole Polytechnique de Louvain, Louvain-la-Neuve, 2017. [8] I. Bouckaert, «Optimisation d'une passerelle de tenségrité soumise à des charges aléatoire,» Université catholique de Louvain, Louvain-la-Neuve, 2019. [9] R. W. Burkhardt, A Practical Guide to Tensegrity Design, 2008. [10] G. A. Tibert et S. Pellegrino, «Review of Form-Finding Methods for Tensegrity Structures,» International journal of Space Structures, n° %118, pp. 209-223, 2003. [11] A. Hanaor, «Aspects of Design of Double-Layer Tensegrity Dome,» International Journal of Space Structures, vol. 7, n° %12, pp. 101-114, 1992. [12] K. Snelson, «Easy Landing,» [En ligne]. Available: http://kennethsnelson.net/sculptures/outdoorworks/easy-landing/. [Accès le 13 mai 2020]. Snelson, «Needle Tower II,» [En ligne]. Available: [13] K. http://kennethsnelson.net/sculptures/outdoor-works/needle-tower-ii/. [Accès le 13 Mai 2020]. [14] R. Cuthbert, «Robby Cuthbert Design,» [En ligne]. Available: http://www.robbycuthbert.com/. [Accès le 13 Mai 2020]. [15] P. Latteur, J. Feron et V. Denoël, «A design methodology for lattice and tensegrity structures based on a stiffness and volume optimization algorithm using morphological indicators,» International Journal of Space Structures, vol. 32, n° %13-4, pp. 226-243, 2017. [16] C. F. Jones, «Kurilpa Bridge,» ArchDaily, 2009. [En ligne]. Available: https://www.archdaily.com/186214/kurilpa-bridge-cox-rayner-architects-with-arup. [17] Atelier Architecture 64, «Tensegrity bridge,» http://www.aa64.net/tensegrity-bridge-atelier.

136

2016.

[En

ligne].

Available:

[18] «Ninety Nine Failures / The University of Tokyo Digital Fabrication Lab,» 2013. [En ligne]. Available: https://www.archdaily.com/469193/ninety-nine-failures-the-university-of-tokyodigital-fabrication-lab. [19] Model Lab, «The Grasshopper Primer,» https://www.modelab.is/grasshopper-primer/.

Avril

2016.

[En

ligne].

Available:

[20] Robert McNeel & Associates, «RhinoCommon API,» 2020. [En ligne]. Available: https://developer.rhino3d.com/api/RhinoCommon/html/R_Project_RhinoCommon.htm. [21] D. Piker, «Kangaroo: Form Finding with Computational Physics,» Architectural Design, vol. 83, n° %12, pp. 136-137, 2013. [22] D. Rutten, «Galapagos: On the Logic and Limitations of Generic Solvers,» Architectural Design, vol. 83, n° %12, pp. 135-135, 2013. [23] T. Wortmann, «Opossum: Introducing and Evaluating a Model-based Optimization Tool for Grasshopper,» 2017. [24] M. Pars, «Ring,» [En ligne]. Available: http://www.tensegriteit.nl/e-ring.html. [Accès le 10 avril 2020]. [25] M. Pars, «Cube,» [En ligne]. Available: http://www.tensegriteit.nl/e-cube.html. [Accès le 10 avril 2020]. [26] T. Tachi, «Interactive Freeform Design of Tensegrity,» Advances in Architectural Geometry, pp. 259-268, 2012. [27] S. Pellegrino, «Structural computations with singular value decomposition of the equilibrium matix,» International Journal of Solids and Structures, vol. 30, n° %121, pp. 3025-3035, 1993. [28] M. Eliaers, «Calcul non-linéaire des structures de tenségrité,» Université catholique de Louvain, Louvain-la-Neuve, 2015. [29] J. Feron, «Optimisation des structures de tenségrité sur base des indicateurs morphologiques,» Université catholique de Louvain, Louvain-la-Neuve, 2016. [30] M. AbdelRahman, GH_CPython: CPython plugin for grasshopper, 2017. [31] Block Research Group, «COMPAS Docs,» dev.github.io/main/index.html. [Accès le 2020].

[En

[32] Python.org, «Built-in Types,» 2020. https://docs.python.org/3/library/stdtypes.html.

ligne]. [En

Available: ligne].

https://compasAvailable:

[33] A. Bastien et Q. Gravy, «Etude d’une passerelle de tenségrité composée de simplex,» Université catholique de Louvain, Louvain-la-Neuve, 2014. [34] P. Latteur, Calculer une structure : de la théorie à l'exemple., Louvain-la-Neuve: Academia, 2016. [35] J.-F. Remacle, LAUCE 2125 - Finite Elements for Structures, 2015. [36] P. Latteur, «Optimisation et prédimensionnement des treillis, arcs, poutres et câbles sur base d'indicateurs morphologiques,» VUB, Bruxelles, 2000. 137

[37] K. Snelson, «Needle Tower,» [En ligne]. Available: http://kennethsnelson.net/sculptures/outdoor-works/needle-tower/. [Accès le 13 Mai 2020].

138

Annexe A. Installation de Python et COMPAS Cette annexe est une compilation des informations disponibles dans la documentation officielle de COMPAS. Elle vise à expliquer l’installation de COMPAS de la manière la plus simple. Tout d’abord, il est conseillé d’utiliser Anaconda [https://www.anaconda.com/]. Il s’agit d’une distribution de Python gratuite et open source spécialisée dans le calcul scientifique. Anaconda offre l’avantage d’offrir une interface graphique permettant la gestion de Python et ses librairies tout en facilitant son installation et en automatisant l’installation des librairies indispensables. Afin de pouvoir installer COMPAS dans Grasshopper, il est nécessaire d’installer la version Python 2.7 d’Anaconda et de cocher la case « Add Anaconda to my PATH environment variable » lors de l’installation.

Une fois Anaconda installé, il est nécessaire de redémarrer l’ordinateur. Ensuite, ouvrir l’invité de commande, ou le terminal sur mac, et entrer la ligne de commande suivante permettant d’activer l’environnement Python dans lequel va être installé COMPAS : activate base source activate base

(pour Windows) (pour Mac)

Il est ensuite nécessaire d’entrer deux lignes de commandes supplémentaires : python -m compas_rhino.install -v 6.0

Puis : python -m compas_rhino.install -p compas_fab

COMPAS est désormais installé dans Rhinoceros et Grasshopper. Il peut être importé dans GhPython au moyen de la ligne : import compas

Dans le cadre d’une installation pour Rhinoceros 5, il est nécessaire de remplacer le -v 6.0 de la première commande par-v 5.0.

Annexe B. Installation du plugin Le programme développé est un plugin Grasshopper. Il est donc nécessaire de l’installer dans Grasshopper à l’instar des autres composants. Actuellement, le programme prend la forme d’un dossier contenant un ensemble de fichier .gphy représentant chacun un composant. Ces fichiers doivent être placés dans le dossier contenant les plugins Grasshopper. Ce dossier est accessible depuis Grasshopper dans le menu supérieur : Fichier>Specials Fodler>Components Folder

Il suffit désormais de placer le dossier contenant les fichiers .ghpy dans le dossier Grasshopper ouvert précédemment. Enfin, afin d'installer le code de calcul, il est nécessaire de récupérer l'archive contenant de code Python et de décompresser celle-ci dans un dossier à part. Ensuite, via l'invité de commande, il faut se placer dans le dossier où est situé le contenant de l'archive et écrire: pip install tensegripy Le plugin est désormais fonctionnel.

Annexe C. Validation des outils de calcul Cette annexe présente les résultats des différents tests réalisés afin de vérifier le fonctionnement du plugin. Ces tests utilisent une méthode comparative afin de déterminer la fiabilité du programme. Les résultats obtenus seront comparés à ceux effectués lors des précédents mémoires ainsi que des résultats disponibles dans la littérature.

C.1. Structures Linéaires C.1.1. Structure 2D simple La structure et les résultats de référence de cette analyse sont tirés du mémoire de Jonas Feron « Optimisation des structures de tenségrité sur base d’indicateurs morphologiques » [29].

Figure 0-1 Schéma statique de la structure analysée [Illustration de l’auteur]

La structure possède les caractéristiques suivantes : 𝐸𝐸 = 10 [𝐺𝐺𝐺𝐺𝐺𝐺]

𝐴𝐴 = 25 [𝑐𝑐𝑚𝑚2 ]

𝐻𝐻 = 1[𝑚𝑚]

La solution linéaire analytique est donnée par : 𝑁𝑁 =

𝐹𝐹 2 sin 𝛼𝛼0

L’analyse donne les résultats suivants : 𝑁𝑁 𝛿𝛿

𝛿𝛿 =

Analytique −70,711 [𝑘𝑘𝑘𝑘] 5,657 [𝑚𝑚𝑚𝑚]

𝐿𝐿 = 2 [𝑚𝑚]

2𝑁𝑁𝑁𝑁𝑙𝑙0 𝐸𝐸𝐸𝐸

𝑙𝑙 = 1 −70,711 [𝑘𝑘𝑘𝑘] 5,657 [𝑚𝑚𝑚𝑚] III

𝐹𝐹 = 100 [𝑘𝑘𝑘𝑘]

𝑙𝑙 = 100 −70,911 [𝑘𝑘𝑘𝑘] 5,681 [𝑚𝑚]

C.1.2. Treillis 2D La structure et les résultats de référence de cette analyse sont tirés du livre de Pierre Latteur « Calculer une structure : de la théorie à l’exemple » [34]. La structure est caractérisée par un facteur 𝐸𝐸𝐸𝐸 = 150.106 [𝑁𝑁].

Figure 0-2 Schéma statique du treillis hyperstatique [34]

Les résultats suivants sont obtenus grâce au plugin au moyen d’une analyse linéaire (𝑙𝑙 = 1) et d’une analyse non-linéaire (𝑙𝑙 = 100). Référence

𝑙𝑙 = 1

𝑙𝑙 = 100

0[𝑚𝑚𝑚𝑚]

𝛿𝛿1,𝑋𝑋

0[𝑚𝑚𝑚𝑚]

𝛿𝛿2,𝑋𝑋

0[𝑚𝑚𝑚𝑚]

𝛿𝛿3,𝑋𝑋

0,333[𝑚𝑚𝑚𝑚]

0,335[𝑚𝑚𝑚𝑚]

𝛿𝛿4,𝑋𝑋

−1,067[𝑚𝑚𝑚𝑚]

−1,07[𝑚𝑚𝑚𝑚]

𝛿𝛿5,𝑋𝑋

0[𝑚𝑚𝑚𝑚]

𝛿𝛿1,𝑌𝑌

𝛿𝛿2,𝑌𝑌 𝛿𝛿3,𝑌𝑌 𝛿𝛿4,𝑌𝑌 𝛿𝛿5,𝑌𝑌

0[𝑚𝑚𝑚𝑚]

2,219[𝑚𝑚𝑚𝑚]

2,886[𝑚𝑚𝑚𝑚]

0[𝑚𝑚𝑚𝑚]

2,226[𝑚𝑚𝑚𝑚] 2,894[𝑚𝑚𝑚𝑚]

5,838[𝑚𝑚𝑚𝑚]

5,846[𝑚𝑚𝑚𝑚]

Référence

𝑙𝑙 = 1

𝑙𝑙 = 100

Tableau 0-1 Comparaison des déplacements des nœuds présentés par le livre et ceux obtenu par une analyse linéaire (𝑙𝑙 = 1) et une analyse non linéaire (𝑙𝑙 = 100)

𝑁𝑁1

25[𝑘𝑘𝑘𝑘]

25,23[𝑘𝑘𝑘𝑘]

𝑁𝑁2 𝑁𝑁3 𝑁𝑁4 𝑁𝑁5 𝑁𝑁6

−25[𝑘𝑘𝑘𝑘] −80[𝑘𝑘𝑘𝑘] 50[𝑘𝑘𝑘𝑘] −70,71[𝑘𝑘𝑘𝑘] −70,71[𝑘𝑘𝑘𝑘]

−24,89[𝑘𝑘𝑘𝑘] −80,11[𝑘𝑘𝑘𝑘] 50,16[𝑘𝑘𝑘𝑘] −70,88[𝑘𝑘𝑘𝑘] −70,84[𝑘𝑘𝑘𝑘]

Tableau 0-2 Comparaison des effort internes présentés par le livre et ceux obtenu par une analyse linéaire (𝑙𝑙 = 1) et une analyse non linéaire (𝑙𝑙 = 100)

On observe des résultats identiques pour la méthode linéaire. La méthode linéaire présente après 100 itérations des résultats très similaires dont la différence minime s’explique par la prise en compte de la non-linéarité. Ces résultats semblent valider le programme pour les structures 2D linéaires tant au moyen d’un analyse linéaire que d’une analyse non-linéaire.

C.1.3. Treillis simplex 0° 3D La structure et les résultats de référence de cette analyse sont tirés du mémoire de Jonas Feron « Optimisation des structures de tenségrité sur base d’indicateurs morphologiques » [29].

Figure 0-3 Schéma statique d’un treillis composé de simplex 𝜃𝜃 = 0 [29]

Il s’agit d’une structure treillis obtenue par assemblage de simplex ayant une rotation relative entre les bases 𝜃𝜃 = 0.

Tous les éléments de la structures partagent les mêmes caractéristiques : 𝐸𝐸 = 210 [𝐺𝐺𝐺𝐺𝐺𝐺] et 𝐴𝐴 = 25 [𝑐𝑐𝑚𝑚2 ]. 𝐵𝐵1 𝐵𝐵2 𝐵𝐵3 𝐵𝐵4 𝐵𝐵5 𝐵𝐵6 𝐵𝐵7 𝐵𝐵8 𝐵𝐵9

Scia −68,84 [𝑘𝑘𝑘𝑘] 0 [𝑘𝑘𝑘𝑘] 68,84 [𝑘𝑘𝑘𝑘] −68,84 [𝑘𝑘𝑘𝑘] 0 [𝑘𝑘𝑘𝑘] 68,84 [𝑘𝑘𝑘𝑘] 28,86 [𝑘𝑘𝑘𝑘] −57,73 [𝑘𝑘𝑘𝑘] −28,87 [𝑘𝑘𝑘𝑘]

𝑙𝑙 = 1 −68,84 [𝑘𝑘𝑘𝑘] 0 [𝑘𝑘𝑘𝑘] 68,84 [𝑘𝑘𝑘𝑘] −68,84 [𝑘𝑘𝑘𝑘] 0 [𝑘𝑘𝑘𝑘] 68,84 [𝑘𝑘𝑘𝑘] 28,86 [𝑘𝑘𝑘𝑘] −57,74 [𝑘𝑘𝑘𝑘] −28,87 [𝑘𝑘𝑘𝑘]

𝑙𝑙 = 100 −68,80 [𝑘𝑘𝑘𝑘] 0,02 [𝑘𝑘𝑘𝑘] 68,89 [𝑘𝑘𝑘𝑘] −68,89 [𝑘𝑘𝑘𝑘] 0,02 [𝑘𝑘𝑘𝑘] 68,89 [𝑘𝑘𝑘𝑘] 28,87 [𝑘𝑘𝑘𝑘] −57,75 [𝑘𝑘𝑘𝑘] −28,87 [𝑘𝑘𝑘𝑘]

𝐵𝐵10 𝐵𝐵11 𝐵𝐵12 𝐵𝐵13 𝐵𝐵14 𝐵𝐵15 𝐵𝐵16 𝐵𝐵17 𝐵𝐵18 𝐵𝐵19 𝐵𝐵20 𝐵𝐵21

𝛿𝛿𝑧𝑧,𝑚𝑚𝑚𝑚𝑚𝑚

0 [𝑘𝑘𝑘𝑘] 0 [𝑘𝑘𝑘𝑘] −57,73 [𝑘𝑘𝑘𝑘] 28,86 [𝑘𝑘𝑘𝑘] −57,73 [𝑘𝑘𝑘𝑘] −28,87 [𝑘𝑘𝑘𝑘] 62,50 [𝑘𝑘𝑘𝑘] 0 [𝑘𝑘𝑘𝑘] −62,50 [𝑘𝑘𝑘𝑘] 62,50 [𝑘𝑘𝑘𝑘] 0 [𝑘𝑘𝑘𝑘] −62,50 [𝑘𝑘𝑘𝑘] 7,614 [𝑚𝑚𝑚𝑚]

0 [𝑘𝑘𝑘𝑘] 0 [𝑘𝑘𝑘𝑘] −57,74 [𝑘𝑘𝑘𝑘] 28,87 [𝑘𝑘𝑘𝑘] −57,74 [𝑘𝑘𝑘𝑘] −28,87 [𝑘𝑘𝑘𝑘] 62,50 [𝑘𝑘𝑘𝑘] 0 [𝑘𝑘𝑘𝑘] −62,50 [𝑘𝑘𝑘𝑘] 62,50 [𝑘𝑘𝑘𝑘] 0 [𝑘𝑘𝑘𝑘] −62,50 [𝑘𝑘𝑘𝑘] 7,614 [𝑚𝑚𝑚𝑚]

0,04 [𝑘𝑘𝑘𝑘] −0,10 [𝑘𝑘𝑘𝑘] −57,75 [𝑘𝑘𝑘𝑘] 28,87 [𝑘𝑘𝑘𝑘] −57,75 [𝑘𝑘𝑘𝑘] −28,87 [𝑘𝑘𝑘𝑘] 62,48 [𝑘𝑘𝑘𝑘] 0,02 [𝑘𝑘𝑘𝑘] −62,56 [𝑘𝑘𝑘𝑘] 62,48 [𝑘𝑘𝑘𝑘] 0,02 [𝑘𝑘𝑘𝑘] −62,56 [𝑘𝑘𝑘𝑘] 7,617 [𝑚𝑚𝑚𝑚]

Tableau 0-3 Comparaisons des résultats de l'analyse réalisée par scia et celles réalisées par les solveur linéaire (𝑙𝑙 = 1) et non-linéaire (𝑙𝑙 = 100) [illustration de l'auteur]

A nouveau, on observe des résultats identiques pour la méthode linéaire et quasi identiques pour la méthode non-linéaire. Ces résultats permettent de considérer le programme comme fonctionnel pour les structures 2D et 3D linéaires.

C.2. Structure non-linéaire La structure et les résultats de référence de cette analyse sont tirés du mémoire de Jonas Feron « Optimisation des structures de tenségrité sur base d’indicateurs morphologiques » [29].

Figure 0-4 Schéma statique de la structure non-linéaire [Illustration de l'auteur]

La structure possède les caractéristiques suivantes : 𝐸𝐸 = 10 [𝐺𝐺𝐺𝐺𝐺𝐺]

𝐴𝐴 = 25 [𝑐𝑐𝑚𝑚2 ]

Le programme renvoie les résultats suivants :

𝐿𝐿 = 2 [𝑚𝑚] VI

𝐹𝐹 = 100 [𝑘𝑘𝑘𝑘]

𝑁𝑁 𝛿𝛿

𝑙𝑙 = 10 285,05 [𝑘𝑘𝑘𝑘] 185,60 [𝑚𝑚𝑚𝑚]

𝑙𝑙 = 50 312,82 [𝑘𝑘𝑘𝑘] 164 [𝑚𝑚𝑚𝑚]

𝑙𝑙 = 100 𝑙𝑙 = 200 𝑙𝑙 = 500 𝑙𝑙 = 1000 313,38 [𝑘𝑘𝑘𝑘] 313,5 [𝑘𝑘𝑘𝑘] 313,53 [𝑘𝑘𝑘𝑘] 313,53 [𝑘𝑘𝑘𝑘] 161,87 [𝑚𝑚𝑚𝑚] 160,86 [𝑚𝑚𝑚𝑚] 160,27 [𝑚𝑚𝑚𝑚] 160,07 [𝑚𝑚𝑚𝑚]

On observe qu’avec peu d’itération le calcul n’est pas précis. Toutefois, au-delà de 𝑙𝑙 = 50, la précision est correcte et on observe le résultat converger. C’est également le résultat mis en évidence par Jonas Feron [29]. En comparant les résultats du programme avec la relation analytique suivante : 𝑢𝑢 2 𝑁𝑁1 = 𝑁𝑁2 = 𝐸𝐸𝐸𝐸 ��1 + � � − 1� 𝐿𝐿0

𝐹𝐹 𝑢𝑢 3 � � = 𝐸𝐸𝐸𝐸 𝐿𝐿0

Il observe également une convergence des résultats vers 313,02 [𝑘𝑘𝑘𝑘] pour les efforts internes et 158,74 [𝑚𝑚𝑚𝑚] pour le déplacement du nœud central.

Figure 0-5 Comparaison de la solution analytique aux résultats du programme pour différentes longueurs d'incrémentation 𝑙𝑙 [Illustration de l'auteur]

Ces résultats valident le solveur non-linéaire et confortent la confiance que l’on peut avoir dans la résolution de structure non-linéaire grâce au programme.

VII

Annexe D. Généralisation de la formulation de l’angle de rotation relative optimal pour une cellule prismatique Cette annexe a pour but de prouver que l’équation démontrée par Tibert et Pellegrino [Tibert, G. A., & Pellegrino, S. (2003). Review of Form-Finding Methods for Tensegrity Structures. International journal of Space Structures(18), 209-223.] reste valable dans le cas d’une cellule prismatique ayant deux bases polygonales régulières de dimensions différentes. Soit deux polygones réguliers d’ordre 𝑣𝑣 ayant une rotation relative 𝜃𝜃 et séparé d’une hauteur 𝐻𝐻. Considérons cinq points 𝑃𝑃𝑖𝑖 :

Voici leurs coordonnées : 𝑃𝑃1 = [𝑅𝑅1 , 0 ,0] 𝑃𝑃2 = [𝑅𝑅2 cos(𝜃𝜃) , 𝑅𝑅2 sin(𝜃𝜃) , 𝐻𝐻] 2𝜋𝜋 2𝜋𝜋 𝑃𝑃3 = �𝑅𝑅2 cos �𝜃𝜃 + � , 𝑅𝑅2 sin �𝜃𝜃 + � , 𝐻𝐻� 𝑣𝑣 𝑣𝑣 2𝜋𝜋 2𝜋𝜋 𝑃𝑃4 = �𝑅𝑅1 cos � � , −𝑅𝑅1 sin � � , 0� 𝑣𝑣 𝑣𝑣 2𝜋𝜋 2𝜋𝜋 𝑃𝑃5 = �𝑅𝑅1 cos � � , 𝑅𝑅1 sin � � , 0� 𝑣𝑣 𝑣𝑣

La longueur des câbles 𝐿𝐿𝑐𝑐 vaut :

𝐿𝐿2𝑐𝑐 = ‖𝑃𝑃1 𝑃𝑃2 ‖ = 𝑅𝑅22 + 𝑅𝑅12 − 2𝑅𝑅1 𝑅𝑅2 cos(𝜃𝜃) + 𝐻𝐻2

La longueur des barres 𝐿𝐿𝑏𝑏 vaut :

𝐿𝐿2𝑏𝑏 = ‖𝑃𝑃1 𝑃𝑃2 ‖ = 𝑅𝑅22 + 𝑅𝑅12 − 2𝑅𝑅1 𝑅𝑅2 cos �𝜃𝜃 +

2𝜋𝜋 � + 𝐻𝐻2 𝑣𝑣

La longueur des barres peut également être réécrite comme suit : 𝜋𝜋 𝜋𝜋 𝐿𝐿2𝑏𝑏 = 4𝑅𝑅1 𝑅𝑅2 sin �𝜃𝜃 + � sin � � + 𝐿𝐿2𝑐𝑐 𝑣𝑣 𝑣𝑣 VIII

Afin d’obtenir l’angle maximisant 𝐿𝐿2𝑏𝑏 pour une longueur 𝐿𝐿𝑐𝑐 donnée, on cherche les zéros de la dérivée de 𝐿𝐿2𝑏𝑏 selon 𝜃𝜃 : 𝜋𝜋 𝜕𝜕𝐿𝐿2𝑏𝑏 𝜋𝜋 = 4𝑅𝑅1 𝑅𝑅2 cos �𝜃𝜃 + � sin � � = 0 𝑣𝑣 𝜕𝜕𝜕𝜕 𝑣𝑣

On observe que le problème est indépendant de 𝐿𝐿𝑐𝑐 . La valeur 𝜃𝜃 optimal est : 1 1 𝜃𝜃 = 𝜋𝜋 � − � 2 𝑣𝑣

On peut ainsi conclure que les angles de rotations relative optimaux sont liés à une typologie de cellule prismatique, ce peu importe la hauteur du prisme ou les dimensions des bases.

Annexe E. Formulation des dimensions dans Grasshopper Cette annexe développe les différentes relations mathématiques utilisées afin d’offrir plus de paramètres lors de la modélisation des structures de tenségrité.

E.1.

Expression du rayon extérieur par le rayon intérieur

Soit un polygone régulier d’ordre 𝑛𝑛 et défini par le rayon de son cercle inscrit 𝑟𝑟𝑖𝑖𝑖𝑖𝑖𝑖 . On souhaite, afin de définir cette géométrie dans Grasshopper, exprimer le rayon du cercle circonscrit 𝑟𝑟𝑒𝑒𝑒𝑒𝑒𝑒 .

Le polygone étant régulier, les segments reliant les sommets adjacents 𝐴𝐴 et 𝐵𝐵 au centre 𝑂𝑂 forment un angle de 2𝜋𝜋⁄𝑛𝑛. 𝑂𝑂𝑂𝑂 la hauteur du triangle 𝐴𝐴𝐴𝐴𝐴𝐴 correspond au rayon du cercle inscrit. On peut donc conclure que 𝑂𝑂𝑂𝑂 ⊥ 𝐴𝐴𝐴𝐴 et ‖𝑂𝑂𝑂𝑂‖ = 𝑟𝑟𝑖𝑖𝑖𝑖𝑖𝑖 . Ainsi, on peut écrire :

cos

𝑟𝑟𝑖𝑖𝑖𝑖𝑖𝑖 𝜋𝜋 𝑟𝑟𝑖𝑖𝑖𝑖𝑖𝑖 = ⟺ 𝑟𝑟𝑒𝑒𝑒𝑒𝑒𝑒 = 𝜋𝜋 𝑛𝑛 𝑟𝑟𝑒𝑒𝑒𝑒𝑒𝑒 cos 𝑛𝑛

E.2.

Expression du rayon extérieur par la longueur des cotés

Soit un polygone régulier d’ordre 𝑛𝑛 et défini par la longueur 𝐿𝐿 d’un de ses cotés. On souhaite, afin de définir cette géométrie dans Grasshopper, exprimer le rayon du cercle circonscrit 𝑟𝑟𝑒𝑒𝑒𝑒𝑒𝑒 .

Le polygone étant régulier, les segments reliant les sommets adjacents 𝐴𝐴 et 𝐵𝐵 au centre 𝑂𝑂 forment un angle de 2𝜋𝜋⁄𝑛𝑛. 𝐴𝐴𝐴𝐴.

𝑂𝑂𝑂𝑂 la hauteur du triangle 𝐴𝐴𝐴𝐴𝐴𝐴 correspond au rayon du cercle inscrit. On peut conclure que 𝑂𝑂𝑂𝑂 ⊥

𝑂𝑂𝑂𝑂 et 𝑂𝑂𝑂𝑂 étant tout les deux les rayons du cercle circonscrit, on peut affirmer que ‖𝑂𝑂𝑂𝑂‖ = ‖𝑂𝑂𝑂𝑂‖ et donc que le triangle 𝐴𝐴𝐴𝐴𝐴𝐴 est isocèle. On en conclut que la hauteur 𝑀𝑀 est le milieu du segment 𝐴𝐴𝐴𝐴 et que ‖𝐴𝐴𝐴𝐴‖ = ‖𝑀𝑀𝑀𝑀‖ = 𝐿𝐿⁄2. On peut donc écrire :

E.3.

𝐿𝐿 𝜋𝜋 𝐿𝐿 sin = 2 ⟺ 𝑟𝑟𝑒𝑒𝑒𝑒𝑒𝑒 = 𝑝𝑝𝑝𝑝 𝑛𝑛 𝑟𝑟𝑒𝑒𝑒𝑒𝑒𝑒 2 sin 𝑛𝑛

Expression de la hauteur d’une cellule prismatique régulière

La définition Grasshopper construit les cellules de tenségrité à partir de nombreux paramètres. L’un d’entre eux est la hauteur 𝐻𝐻 de la cellule. On souhaite déterminer la hauteur 𝐻𝐻 nécessaire afin d’obtenir une cellule prismatique régulière. C’est-à-dire dont l’ensemble des câbles ont la même longueur.

Soit une cellule prismatique de hauteur 𝐻𝐻 basée sur un polygone d’ordre 𝑛𝑛 et dont les bases ont un angle de rotation relative 𝜃𝜃. Considérons trois points 𝐴𝐴, 𝐵𝐵 et 𝐶𝐶 dont les coordonnées dans un repère cylindrique sont : 𝐴𝐴 = [𝑟𝑟, 0, 0] 𝐵𝐵 = [𝑟𝑟, 𝜃𝜃, 𝐻𝐻] 2𝜋𝜋 𝐶𝐶 = �𝑟𝑟, 𝜃𝜃 + , 𝑧𝑧� 𝑛𝑛

La distance entre deux points dans un repère cartésien tridimensionnel est définie comme : �Δ𝑥𝑥 2 + Δ𝑦𝑦 2 + Δ𝑧𝑧 2

Sachant que le rayon des points est constant et que la transformation des coordonnées cartésiennes à des coordonnées polaire est : 𝑥𝑥 = 𝑟𝑟 cos 𝜃𝜃 � 𝑦𝑦 = 𝑟𝑟 sin 𝜃𝜃 𝑧𝑧 = 𝑧𝑧

On peut écrire la distance entre deux points 𝑃𝑃1 et 𝑃𝑃2 comme :

‖𝑃𝑃1 𝑃𝑃2 ‖2 = 𝑟𝑟 2 (cos 𝜃𝜃2 − cos 𝜃𝜃1 )2 + 𝑟𝑟 2 (sin 𝜃𝜃2 − sin 𝜃𝜃1 )2 + (𝑧𝑧2 − 𝑧𝑧1 )2

Ainsi, on a :

‖𝐴𝐴𝐴𝐴‖2 = 2𝑟𝑟 2 (1 − cos 𝜃𝜃 ) + 𝐻𝐻2 𝜋𝜋 ‖𝐵𝐵𝐵𝐵‖ = �2𝑟𝑟 sin � 𝑛𝑛

En posant ‖𝐴𝐴𝐴𝐴‖2 = ‖𝐵𝐵𝐶𝐶‖2 on obtient :

𝜋𝜋 2

2𝑟𝑟 2 (1 − cos(𝜃𝜃)) + 𝐻𝐻2 = �2𝑟𝑟 sin � 𝑛𝑛

Enfin, en isolant 𝐻𝐻, on détermine la hauteur d’une cellule prismatique en fonction du polygone de référence, du rayon du cercle circonscrit au polygone de référence 𝑟𝑟 et de la rotation relative entre les bases 𝜃𝜃 : 𝜋𝜋 2 𝐻𝐻 (𝑛𝑛, 𝑟𝑟, 𝜃𝜃) = ��2𝑟𝑟 sin � − 2𝑟𝑟 2 (1 − cos 𝜃𝜃) 𝑛𝑛

XII