• Modèle de calcul de structure automatique de bâtiments en B.A.

    Modèle de calcul de structure automatique de bâtiments en béton armé

    Ce projet a pour objectif de développer un module permettant la réalisation d'un modèle de structure SAP ou Robot pour le calcul de bâtiments en béton armé sur la seule base d'un plan architecte.

    La pratique du métier d'ingénieur en calcul de structure conduit à réaliser très souvent, pour chaque projet, une modélisation dans un logiciel dédié : SAP, Robot ou encore Graitec Advance.
    Dans la pratique, nous apprenons vite que ces logiciels ont besoin d'une modélisation particulièrement rigoureuse, inhérente à la problématique du calcul aux éléments finis. En effet, lorsqu'un modèle, surtout avec Robot, n'est pas parfaitement propre, le maillage automatique aux éléments finis provoquent son lot d'erreur, en particulier une accumulation importante de mailles aux endroits ou les plaques de structure (dalles ou voile) ne se rencontre pas parfaitement. Ces erreurs de modélisation provoquent donc un accroissement important de la taille du fichier, du temps de calcul et une fragilisation de pertinence des résultats obtenus.

    Le module proposé dans ce projet veut donc répondre à deux problématiques importantes :

    • Automatiser l'ensemble des étapes de base de la création du modèle de structure, en réduisant le travail de l'ingénieur au minimum afin de libérer un gain de temps appréciable et optimiser ainsi le coût du personnel sur le projet.
    • Permettre une modélisation parfaitement propre, supprimant du même coup le risque évoqué d'un maillage imparfait.

    Ce projet nécessite le plug-in (payant) Geometry Gym de Jon Mirtschin pour effectuer la passerelle entre le modèle Grasshopper et le logiciel de calcul (SAP ou Robot)  et celui (gratuit) de BullAnt (optionnel, une définition Grasshopper donnée dans l'article permet, un peu plus fastidieusement, de s'en passer).

    PARTIE 1 - DÉFINITION DU BESOIN

    I-1 - Données d'entrée

    L'objectif étant de réduire le temps nécessaire à l'ingénieur pour la création de son modèle de calcul, il faut que les données d'entrée soient réduites au minimum.

    Le fichier AutoCAD de l'architecte est ouvert. Ici, par exemple, un plan du projet 3 Black Swans à Strasbourg (architecte : Architectures Anne Demians).

    Le travail manuel consiste à rajouter à la main les lignes des voiles et des poutres et les points des poteaux... et c'est tout.
    S'il existe plusieurs étages, faire de même à chaque étage. 

    Il est important de bien respecter le positionnement dans des calques précisément nommés :

    • Les six premières lettres serviront à déterminer le type d'éléments : poteau, poutre ou voiles
    • Après une espace on insère la section :
      • S'il s'agit d'un voile, insérer simplement l'épaisseur en mètres.
      • S'il s'agit d'un élément filaire (poutre ou poteau), insérer STD R(m) pour une section rectangulaire et STD C(m) pour une section circulaire puis une espace et la hauteur mètre, une autre espace et la largeur en mètre (s'il s'agit d'une section circulaire, se contenter du diamètre).

    Il est important de noter que ce tracé peut être extrêmement grossier. Pour preuve, l'exemple ci-dessous contient des traits pas droits, des intersections trop longues ou trop courtes :

             

    Une fois cela réalisé, il ne reste plus qu'à importer les données d'AutoCAD vers Rhino (pour cet exemple, nous réaliserons un modèle avec deux niveaux). Les données d'entrée sont maintenant intégrées.

    Dans le module Grasshopper, il faudra uniquement préciser la hauteur de la toiture, l'épaisseur des dalles et le pas souhaité pour le modèle (pas en-dessous duquel les éléments seront fusionnés). Le module exécutera immédiatement la construction du modèle et l'enverra dans le logiciel de calcul (SAP ci-dessous) :

    A ce stade, l'ingénieur dispose d'un modèle contenant tous les éléments, les étages, et avec les bonnes épaisseurs en seulement une poignée de minutes (le temps de réaliser un tracé assez grossier sur AutoCAD). Le gain de temps est donc très profitable. De plus, on remarquera que toutes les plaques sont bien divisées sur une grille identique à tous les étages ce qui permet d'assurer que le maillage sera rapide et sans défauts.

    Passons maintenant à la réalisation du module Grasshopper permettant d'effectuer cette tâche automatique.

    PARTIE 2 - TRACÉ DES FILES DE STRUCTURE

    II-1 - Traitement des données d'entrée

    L'objectif est de permettre une modélisation immédiate pour un ingénieur qui ne connait rien (ou presque) à Grasshopper.

    Il faut donc permettre un chargement automatique de toutes les données d'entrée via l'import AutoCAD dans Rhino, puis un tri entre les points (qui deviendront les poteaux) et les lignes (qui seront soit des voiles soit des poutres). Enfin, il sera pris comme principe de base que tout type de données pourront être triés : on ne sait pas dans quel ordre sont faits les calques, on ne sait pas non plus s'il y aura forcément des poteaux dans le projet, ou des poutres, ect. Il faut donc procéder à un tri universel des données qui ne demande pourtant aucune action à l'utilisateur du module.

    Dans Grasshopper, voici les étapes qui mènent au tri universel des données d'entrée :

    • Extraction des géométries :
      • Avec un Pipeline, on récupère toutes les géométries du fichier Rhino, les géométries Points et Curves sont sélectionnées et sont groupées par Layer.
    • Tri des types de géométries :
      • Des inputs Points et Curves sont reliées à la Pipeline, il reste à retirer les éléments Null (c'est-à-dire les index des points dans les courbes et inversement), ce qui se fait avec deux Dispatch dont le Pattern est généré par deux composants Null reliés respectivement aux Points et aux Curves.
      • Des inputs Points  et Curves "Lignes importées" à la sortie des Dispatch permettent de garder de côté la liste des Points et des Curves pour les autres étapes.

    Ci-dessous le logigramme du traitement des données d'entrée : 

     

    II-2 - Hauteurs des planchers

    Dans cette partie, nous allons créer quelques groupes d'hauteurs d'étages et de vecteurs afin de positionner plus tard en altimétrie tous les éléments du modèle.

    Dans Grasshopper, voici les étapes qui mènent à la création des hauteurs de planchers :

    • Créations des valeurs et des vecteurs d'altimétrie des planchers :
      • Un Number Slider "Hauteur de la toiture" permet de choisir cette valeur.
      • Un Create Set permet d’extraire des coordonnées Z des points les valeurs des altimétries de chaque plancher.
      • Sort List trie les altimétries du rez-de-chaussée jusqu'à l'étage le plus haut.
      • On garde ces valeurs dans un input Number "Set RDC + étages" pour plus tard et, avec un vecteur Unit Z sur l'output Keys du Sort List, on obtient les vecteurs correspondants que l'on stocke dans un input Vector "Vecteurs RDC + étages".
      • Merge permet de souder ces altimétries (input Data 1) avec celle de la Hauteur de la toiture (input Data 2).
      • Cull Index sur cette liste avec l'input Indices à 0 permet de supprimer le rez-de-chaussée.
      • Un vecteur Unit Z sur ces valeurs donne les vecteurs correspondants à stocker dans un input Vector "Vecteurs étages + toiture".
      • Enfin une Substraction entre ces valeurs et le Set RDC + étages donne une liste des hauteurs de chaque étage à stocker dans un input Vector "Set Hauteurs d'étages".

    Ci-dessous le logigramme qui permet d’obtenir les hauteurs et vecteurs d'étages :

     

    II-3 - Réalisation de la grille

    Il faut maintenant créer une grille, correspondant peu ou prou aux files de structure, sur laquelle ont projettera les différents éléments.

    Afin de gérer les petits écarts de géométrie du fichier de base et de ne pas créer trop d'éléments dalles de très petites dimensions - ce qui ralentirait le maillage et le calcul aux éléments finis - , la grille doit recaler tous les éléments dont les extrémités divergent un petit peu. Un pas, en mètres, sera donc intégré et correspondra au degré de finesse de la grille. Aucun élément de longueur inférieure à ce pas ne sera créé.

    Dans Grasshopper, voici les étapes qui mènent à la création de la grille de base :

    • Récupération des points du modèles :
      • On ré-insère les inputs  et "Lignes importées" (Wire Display Hidden pour la visibilité).
      • End Points sur le composant Lignes importées permet d’extraire les points de début et de fin des voiles et des poutres.
      • Les points de Points importés et de End Points sont insérés dans un unique input Points et décomposés avec Deconstruct afin d'en obtenir les coordonnées.
    • Définition des écarts de la grille :
      • Un Sort List permet de trier les coordonnées X des points.
      • Deux Shift List décalent la liste triée avec respectivement des offset de -1 et 1 (output Wrap en False pour supprimer respectivement la première et la dernière coordonnée).
      • Substraction entre ces deux Shift List permet d'obtenir les écarts en X de tous les points.
      • La même opération est réalisée avec les coordonnées Y.
    • Simplicitation de la grille (selon la finesse du pas) :
      • Un Number Slider "Précision [m]" permet de gérer le pas de finesse, dans l'exemple il est réglé à 0,4 mètre.
      • Un composant Larger Than compare les écarts des coordonnées X (input A) avec le pas (input B).
      • Un composant Merge fusionne un Boolean Toggle en True (afin de garder la toute première coordonnée) avec l'output > du Larger Than .
      • Enfin, un Cull Pattern supprimera des écarts entre coordonnées X (input List to cull) les index définis par le Merge (input Pattern), les coordonnées X restantes sont ainsi séparées d'au minimum par le pas requis.
      • La même opération est réalisée avec les coordonnées Y.
    • Tracé de la grille :
      • Deux Construct Point recueillent les écarts en X dans l'input X coordinate et les écarts en Y dans l'input Y coordinate -  l'input X coordinate du premier et l'input Y coordinate du second sont en mode Graft.
      • Deux Polyline relient ces points et donnent respectivement les lignes en X et en Y de la grille.
      • Merge fusionne ces lignes (output passé en mode Flatten), on les rentre dans un input Curve appelé "GRILLE BASE LIGNES" pour plus tard.
      • Move permet de déplacer ces lignes fusionnées issues de Merge (output en mode Flatten) dans l'input Base Geometry) et les déplace selon les Vecteurs RDC + étages (en mode Graft dans l'input Motion) - le résultat (des grilles à chaque étages) est stocké (en mode Flatten) pour plus tard dans un input Curves appelé "GRILLE LIGNES".
      • Les écarts des coordonées X et Y sont respectivement insérés dans les input A et B d'un Cross Reference (mode Holistic) d'un Construct Point ce qui permet de créer une grille de points.
      • De même que pour les lignes, cette grille est déplacée à chaque étage avec Move, toujours selon les Vecteurs RDC + étages (en mode Graft dans l'input Motion) - le résultat (des grilles de points à chaque étages) est stocké (en mode Flatten) pour plus tard dans un input Points appelé "GRILLES POINTS ".

    Ci-dessous le logigramme de réalisation de la grille :

     

    PARTIE 3 - CRÉATION DES GÉOMÉTRIES STRUCTURALES

    III-1 - Définition des dalles

    Pour créer des dalles exportables dans SAP, il suffit de transformer la grilles en surfaces. Ainsi toutes les dalles seront bien découpées et aucun élément vertical n'arrivera ailleurs qu'à un des sommets de la dalle. Cela permet d'éviter des erreurs de maillage (ce problème est cependant assez particulier au logiciel ROBOT).

    Dans Grasshopper, voici les étapes qui permettent de définir les dalles comme éléments de structure :

    • Géométrie des dalles :
      • L'input GRILLE BASE LIGNES est réutilisée (Wire Display en mode Hidden pour la visibilité) et intégré au composant de BullAnt ggCurvesSplitIntersect.
      • L'output de ggCurvesSplitIntersect est insérée (en mode Flatten) dans le composant de BullAnt ggNetWorkPolygons, on obtient ainsi les surfaces des polygones définis par les intersections des lignes de la grille.
    • Dalles pour SAP :
      • Les polygones sont insérés dans un Deconstruct Brep dont les outpout Edges sont jointes avec Join Curves afin d'obtenir les contours des dalles.
      • Le résultat est déplacé avec Move selon les Vecteurs étages + toiture, ce qui place les dalles sur les étages (hormis RdC) et la toiture, Flip Curve permet d'orienter correctement ces contours.
      • Avec Geometry Gym, on crée un propriété de Dalles : un panel "DALLES" dans l'input Name, un Number Slider pour régler l'épaisseur des dalles (ici à 0,20m) dans l'input Thickness et, dans l'input Matérial, un ggSAPCreate Concrete pour le béton (la nuance se choisi dans l'input Standard Structure Concrete - dans l'exemple, il s'agit d'un béton C35).
      • Avec ggSAPCreateArea (toujours de Geometry Gym), avec la propriété DALLES en input Prop et les périmètres des dalles de l'output de Flip Curve en input Perimeter, nous créons les éléments structuraux Dalles pour SAP.

    Ci-dessous le logigramme de la définition des dalles : 

     

    III-2 - Définition des poteaux

    Seuls les poteaux sont insérés en tant que points. Ce sera la donnée d'entrée pour le tri. La difficulté réside dans le code permettant de retrouver le nom du calque, contenant les informations sur la section des poteaux, à partir de ces points.

    Dans Grasshopper, voici les étapes qui permettent de définir les poteaux comme éléments de structure :

    • Arbre des points :
      • L'input Points importés est réutilisée (Wire Display en mode Hidden pour la visibilité), Prune Tree enlève les branches vides de l'arbre (correspondant aux voiles et aux poutres) que nous simplifions avec Simplify Tree.
    • Géométrie des poteaux :
      • Closest Point permet de chercher les points de la GRILLE POINTS (input Cloud) les plus proches de ceux des poteaux (input Point).
      • Deconstruct extrait les coordonnées de ces points.
      • Replace Members appliqué sur les coordonnées Z (input Set) remplace les altimétries de SET RDC + étage (input Find) par la hauteur de l'étage correspondant (Set Hauteurs d'étages dans l'input Replace).
      • Avec Unit Z appliqué sur ces valeurs, on obtient les vecteurs correspondants aux hauteurs d'étages en association avec chaque point des poteaux.
      • Il ne reste donc qu'à déplacer les points de la grille proches des poteaux avec Move sur la base de ces vecteurs et de créer les Line entre ces deux arbres de points pour obtenir les lignes directrices des poteaux.
    • Extraction des sections :
      • L'input ID en sortie de l'arbre des points permet d'en extraire des Guids unique par objet.
      • Ces ID sont des données d'entrée pour le composant ObjLay, nom donné au code VB qui va retrouver le nom des calques des objets. Ce code, proposé par Andrew Heumann sur le forum Grasshopper est le suivant :

    Private Sub RunScript(ByVal obj As Guid, ByRef A As Object)
         Dim rh_obj As New Rhino.DocObjects.ObjRef(obj)
         Dim lay_idx As Int32 = rh_obj.Object().Attributes.LayerIndex
         A = String.Format("{0}", doc.Layers.Item(lay_idx).Name)
    End Sub 

      • List Item (input Index à 0), permet d'extraire une seule fois le nom du calque pour chaque branche de l'arbre.
      • Avec le composant Evaluate contenant la fonction right(x,length(x)-7), on ne garde que le nom de la section.
    • Poteaux pour SAP :
      • ggSAPCreateFrameProp crée les propriétés des poteaux, il faut y insérer un composant ggSAPCreate Concrete dans l'input Material et les noms des sections à dans les inputs Profile et Name.
      • ggSAPCreateFrame permet de créer les éléments structuraux Poteaux pour SAP, on y insère les propriétés des poteaux dans l'input Prop et les lignes des géométries dans l'input Node/CL.

    Ci-dessous le logigramme de la définition des poteaux : 

     

    III-3 - Définition des poutres et des voiles

    Dernière étape de ce projet, la définition des poutres et des voiles comme éléments de structure dans SAP. La seule nouveauté est qu'il est souhaitable de découper les voiles et les poutres en fonction de la grille car les logiciels de calcul de structures, en particulier Robot, n’apprécient pas, lors des calculs aux éléments finis, que plusieurs plaques se rejoignent au milieu de l'arrête d'une autre plaque.

    Dans Grasshopper, voici les étapes qui permettent de définir les poutres et voiles comme éléments de structure :

    • Géométrie des lignes des poutres et des voiles :
      • L'input Lignes importés est réutilisée (Wire Display en mode Hidden pour la visibilité), Prune Tree enlève les branches vides de l'arbre (correspondant aux points des poteaux) que nous simplifions avec Simplify Tree.
      • End Points extrait les points de départ et de fin de chaque ligne.
      • Deux composants Closest Point vont permettre de chercher les points de la GRILLE POINTS (inputs Cloud) les plus proches de ceux des débuts et des fins de chaque lignes (inputs Point).
      • Un composant Line relie les deux Closest Point afin de créer les lignes des poutres et des voiles adaptées à la grille.
    • Découpage des lignes sur la grille :
      • Le composant Curve / Curve appliqué entre les lignes obtenues (input A en mode Graft) et les GRILLE LIGNES (input B) extrait tous les points aux intersections entre les lignes des poutres et des voiles et celles de la grille.
      • Shatter va ainsi couper les lignes (input Curve en mode Graft) suivant les outputs Params A du composant Curve / Curve, lesquels auront préalablement été réorganisés avec un Path Mapper {A;B;C} -> {A;B}.
    • Séparation entre les poutres et les voiles - Association avec leur sections :
      • Un composant Deconstruct extrait les coordonnées des points du milieu des lignes coupées (obtenus via un composant Point on Curve à 0.5).
      • Replace Members appliqué sur les coordonnées Z (input Set) remplace les altimétries de SET RDC + étage (input Find) par la hauteur de l'étage correspondant (Set Hauteurs d'étages dans l'input Replace).
      • Avec Unit Z appliqué sur ces valeurs, on obtient les vecteurs correspondants aux hauteurs d'étages en association avec chaque lignes des poutres et des voiles. On simplifie les arbres de ces données avec un Path Mapper {A;B;C} -> {A}.
      • On simplifie également l'arbre des lignes coupées avec un Path Mapper {A;B;C} -> {A}.
      • Un input ID en sortie de l'arbre des lignes sera la données d'entrée du même composant ObjLay que celui évoqué pour les poteaux et qui va retrouver le nom des calques des lignes. 
      • Avec, d'une part, un composant Evaluate contenant la fonction right(x,length(x)-7), on ne garde que le nom de la section.
      • Et avec, d'autre part, un composant Evaluate contenant la fonction if(left(x,6)="Voiles",true,false), on obtient un Pattern qui associe un Boolean True avec les voiles et un False avec les poutres.
      • Ce Pattern sera le motif de tri (input Dispatch Pattern) de trois composants Dispatch qui vont trier, en fonction que les lignes sont associées aux poutres (output A) ou aux voiles (output B), les données suivantes : les noms des sections, les lignes découpées, les vecteurs d'hauteurs d'étages. 
    • Géométrie des voiles :
      • Trois composants Prune Tree enlèvent les branches vides (correspondant aux branches des poutres) des trois arbres de sortie (outputs A) des composants Dispatch
      • Les lignes des voiles sont extrudées avec Extrude suivant les vecteurs d'hauteurs d'étages.
    • Voiles pour SAP :
      • Deconstruct Brep appliqué aux voiles extrudés permet d'extraire les bords (output Edges) qui seront joints avec Joint Curves afin de recréer les périmètres des voiles. On réorganise cet arbre avec un Path Mapper {A;B;C} -> {A}.
      • List Item (input Index à 0), permet d'extraire une seule fois les épaisseurs pour chaque branche de l'arbre des voiles.
      • ggSAPCreateShellProp crée les propriétés des voiles, il faut y insérer un ggSAPCreate Concrete dans l'input Material et les épaisseurs des voiles dans les inputs Name et Thickness.
      • ggSAPCreateArea permet de créer les éléments structuraux Voiles pour SAP, on y insère les propriétés des voiles dans l'input Prop et leurs périmètres dans l'input Perimeter.
    • Géométrie des poutres :
      • Trois composants Prune Tree enlèvent les branches vides (correspondant aux branches des voiles) des trois arbres de sortie (outputs B) des composants Dispatch
      • Les lignes des voiles sont déplacées sur les planchers hauts avec Move suivant les vecteurs d'hauteurs d'étages.
    • Poutres pour SAP :
      • List Item (input Index à 0), permet d'extraire une seule fois les sections pour chaque branche de l'arbre des poutres.
      • ggSAPCreateFrameProp crée les propriétés des poutres, il faut y insérer un ggSAPCreate Concrete dans l'input Material et les épaisseurs des voiles dans les inputs Profile et Name.
      • ggSAPCreateFrame permet de créer les éléments structuraux Poutres pour SAP, on y insère les propriétés des poutres dans l'input Prop et les lignes des poutres dans l'input Node/CL.

    Ci-dessous le logigramme de la définition des poutres et des voiles : 

     

    • Envoi de la géométrie dans le logiciel de calcul :
      • Le composant ggSAPBakeModel assure la passerelle automatique entre Grasshopper et le logiciel SAP.

    Ci-dessous le logigramme complet de la définition Grasshopper : 

    Modèle de calcul de structure automatique de bâtiments en B.A.

     Ci-dessous la version complète de la définition Grasshopper avec le fichier de base sous Rhino.

     La propriété intellectuelle revient à l'auteur. L'usage est libre mais merci de contacter l'auteur via le blog et d'en
     citer la source pour toute utilisation commerciale ou non commerciale. 

       Modélisation Structurale - Parametric Lab - IndB.gh

    Grasshopper - Séance 3 Modélisation Structurale - Parametric Lab.3dm

     


    Tags Tags : , , , , , , , , , , ,
  • Commentaires

    1
    Jeudi 23 Avril 2015 à 13:28

    Bonjour Marc, 

    Jon vient de me transmettre votre lien : félicitations sur le fond comme sur la forme et merci d'avoir mis en accès libre votre travail.

    Avec votre permission, je souhaiterais positionner cet article (ou le lien) sur la partie de mon site dédiée à Geometry Gym et/ou bien dans la rubrique "Témoignages Clients".

    Merci donc de votre retour.

    Pour information, sachez que Rhinoforyou a son nouveau Responsable "R&D", un ingénieur du bâtiment notamment spécialisé sur des structures en membranes textiles, un expert de Grasshopper et autres outils/langages de programmation de Rhino, et bien sûr des connecteurs de Jon (IFC notamment et aussi Robot).

    Bien Cordialement, 

     

    Suivre le flux RSS des commentaires


    Ajouter un commentaire

    Nom / Pseudo :

    E-mail (facultatif) :

    Site Web (facultatif) :

    Commentaire :