2 · Composition de fonctions

Objectif

Étendre le workflow du chapitre 1 pour calculer la force horizontale $F_w$ du vent sur le panneau (§7.4.3 de l’EN 1991-1-4) puis le moment de flexion $M_\text{base}$ au pied du poteau via un operator natif multiply. Durée estimée : 15-20 min.

Pré-requis

• Tu as terminé le chapitre 1 (ou tu as importé le .workflow.yaml correspondant).
• Le package eurocode-1-1-4 (version ≥ 0.3.2) est déployé.

Ce que tu vas apprendre

À la fin de ce chapitre, tu sauras :

• Ajouter un deuxième nœud fonction à un workflow existant.
• Partager un Input ou un Constant entre plusieurs fonctions (DRY).
• Utiliser un operator natif (multiply) pour combiner deux ports typés.
• Profiter de l’inférence dimensionnelle : MecaPy déduit automatiquement le type de sortie à partir des dimensions SI des opérandes ($\text{Force} \times \text{Length} = \text{Moment}$).
• Déclarer plusieurs sorties sur un même workflow.

Le calcul qu’on va modéliser

Notre panneau de signalisation est exposé au vent réglementaire calculé au ch01. La norme §7.4.3 donne la force horizontale résultante :

$$F_w \;=\; c_s c_d \;\cdot\; c_f \;\cdot\; q_p(z_e) \;\cdot\; A_\text{ref}$$

où :

• $A_\text{ref} = b \cdot h$ est l’aire du panneau,
• $c_f = 1{,}80$ est imposé par la norme pour un panneau isolé du sol ($z_g > h/4$),
• $z_e = z_g + h/2$ est la hauteur de référence (centre du panneau),
• $c_s c_d = 1{,}0$ par défaut (structures < 15 m, §6.2(1)(a)).

La fonction Fw_signboard du package eurocode-1-1-4 fait tout ça d’un coup et renvoie aussi le moment de torsion $M = F_w \cdot e$ avec $e = 0{,}25 \cdot b$ (excentricité worst-case §7.4.3).

Pour le moment de flexion au pied du poteau, on multiplie la force horizontale par son bras de levier :

$$M_\text{base} \;=\; F_w \;\cdot\; z_e$$

C’est là qu’intervient l’operator natif multiply — pas besoin de re-coder un handler Python pour une multiplication scalaire.

Pour notre panneau :

• $b = 3{,}00\ \text{m}$ (largeur)
• $h = 2{,}00\ \text{m}$ (hauteur)
• $z_g = 2{,}40\ \text{m}$ (bord inférieur au-dessus du sol)

→ $z_e = 3{,}40\ \text{m}$ (cohérent avec le ch01), $A_\text{ref} = 6{,}00\ \text{m}^2$.

Résultats attendus :

Grandeur	Valeur	Unité
$q_p(z_e)$	≈ 722	Pa
$F_w$	≈ 7,80	kN
$M_\text{torsion}$	≈ 5,85	kN·m
$M_\text{base}$	≈ 26,5	kN·m

Étapes

1. Repartir du workflow ch01

   Ouvre le workflow du chapitre 1 (ou importe le .workflow.yaml de référence si tu pars de zéro). Tu devrais voir : le nœud qp, les 3 inputs qp.vb_0 / qp.z / qp.terrain, la constante rho, et le nœud output.

   

2. Ajouter le nœud fonction Fw_signboard

   Clic droit sur une zone libre du canvas → Add function node. Dans le picker :

   • Package : eurocode-1-1-4
   • Version : 0.3.2
   • Function : Fw_signboard

   Le nœud apparaît avec ses 11 ports d’entrée (7 que tu connais déjà depuis qp + 4 nouveaux : b, h, z_g, c_scd) et ses 9 ports de sortie ($F_w$, $M$, $e$, $z_e$, $A_\text{ref}$, $c_f$, $c_{scd}$, $q_p(z_e)$, $v_b$, $q_b$ — la chaîne §4 est ré-évaluée en interne).

   

3. Partager les inputs déjà existants

   Le nœud Fw_signboard réclame vb_0, terrain, rho — qu’on a déjà côté qp. Plutôt que de créer 3 nouveaux Input/Constant, on branche les nœuds existants sur les ports correspondants du nouveau nœud.

   Tire un fil :

   • de qp.vb_0 (output value) vers Fw_signboard.vb_0
   • de qp.terrain (output value) vers Fw_signboard.terrain
   • de rho (output value) vers Fw_signboard.rho

   Un même Input/Constant peut alimenter plusieurs ports — c’est la garantie qu’on calcule $q_p$ et $F_w$ avec les mêmes valeurs physiques.

   

4. Créer les 3 nouveaux inputs depuis les ports

   Pour b, h, z_g (qui n’ont pas d’équivalent côté qp), on utilise le geste port-drop du ch01 : clic sur le port d’entrée, drag jusqu’à une zone vide du canvas, relâche → popup → Add input.

   Port	Type	Label auto-rempli
   b	Length	Fw_signboard.b
   h	Length	Fw_signboard.h
   z_g	Length	Fw_signboard.z_g

   Le port c_scd reste non-connecté — il a une valeur par défaut de 1.0 dans le manifest (cf. ch01 pour le mécanisme).

   

5. Ajouter l’operator multiply

   Pour le moment au pied, on multiplie $F_w$ par $z_e$. Clic droit sur le canvas → Add operator → choisir multiply.

   L’operator a 2 ports d’entrée génériques (a, b) et un port de sortie (result). Connecte :

   • Fw_signboard.Fw → multiply.a
   • Fw_signboard.z_e → multiply.b

   

   

   Inférence dimensionnelle

   MecaPy déduit que la sortie de multiply(Force, Length) est de type Moment — les vecteurs de dimensions SI des opérandes sont sommés ($\text{kg} \cdot \text{m} \cdot \text{s}^{-2}$ × $\text{m}$ = $\text{kg} \cdot \text{m}^{2} \cdot \text{s}^{-2}$). Pas besoin de déclarer manuellement le type de sortie ; le port est typé Moment automatiquement.

6. Déclarer les 3 outputs

   On veut publier 3 grandeurs au lieu d’une seule. Clic droit canvas → Add output, trois fois :

   Output	Source
   Fw	Fw_signboard.Fw (Force)
   M_torsion	Fw_signboard.M (Moment)
   M_base	multiply.result (Moment)

   Tu peux conserver le nœud output d’origine pour $q_p$ ou le supprimer — selon que tu veux exposer aussi la pression dynamique ou seulement les efforts mécaniques.

   

7. Sauvegarder + exécuter

   Save, puis Run en renseignant tous les inputs :

   Input	Valeur
   qp.vb_0	26.0
   qp.z	3.40
   qp.terrain	"II"
   Fw_signboard.b	3.00
   Fw_signboard.h	2.00
   Fw_signboard.z_g	2.40

   Sur la page du run, les 3 sorties :

   $$\begin{aligned} F_w &\approx 7{,}80\ \text{kN} \\ M_\text{torsion} &\approx 5{,}85\ \text{kN}\cdot\text{m} \\ M_\text{base} &\approx 26{,}5\ \text{kN}\cdot\text{m} \end{aligned}$$

   

Ce que tu viens de faire

• Composition : deux fonctions normatives chaînées dans un même graphe, partageant leurs inputs communs (cohérence garantie).
• Operator natif : une multiplication scalaire ne nécessite pas de package Python — multiply est évalué dans l’orchestrateur, zéro container.
• Typage dimensionnel : $F_w \times z_e \to M$ inféré automatiquement, sans déclaration manuelle.
• Multi-output : un workflow MecaPy peut publier autant de grandeurs que tu veux ; chaque output devient une clé dans la réponse du run.

Récupérer le workflow tout fait

📥 Télécharger ch02-force-vent.workflow.yaml

Import via Workflows → Import ; MecaPy résout Fw_signboard par le digest source du package eurocode-1-1-4@0.3.2.

Prochain chapitre

3 · Combinaisons d’actions (à venir) : on introduit les combinaisons ELU/ELS de l’EC0 via l’operator scale (multiplication par les coefficients de pondération $\gamma_G$, $\gamma_Q$, $\psi_0$, …) et on prépare le terrain pour les vérifications EC3.