Ce code importe tous les modules nécessaires pour :

 Créer une interface graphique avec Tkinter.

 Réaliser des calculs mathématiques.
 Gérer les dates.
 Générer un fichier Word avec du texte formaté et des tableaux.
 Interagir avec le système de fichiers.
 Utiliser les fonctions système de Python.

Voici une explication ligne par ligne de ce bloc de code Python :

import tkinter as tk

 But : Importe le module tkinter, qui est utilisé pour créer des interfaces graphiques en
Python.
 Alias : On l'importe avec l'alias tk pour l'utiliser plus facilement, par exemple [Link],
[Link], etc.

from tkinter import ttk, messagebox

 ttk : Fournit des widgets modernes avec des thèmes (par exemple : [Link],
[Link]) améliorant l'apparence de l'interface.
 messagebox : Permet d'afficher des boîtes de dialogue comme des alertes, messages
d'information, d’erreur ou de confirmation ([Link](),
[Link](), etc.).

import math
  But : Importe le module mathématique standard qui fournit des fonctions comme
[Link](), [Link](), [Link], etc.

from datetime import datetime

 But : Importe la classe datetime depuis le module datetime.

 Utilisation : Sert à gérer des dates et heures, comme obtenir la date actuelle :
[Link]().

from docx import Document

 But : Importe la classe Document du module python-docx.

 Utilisation : Permet de créer ou modifier des fichiers Word (.docx) via Python. Par
exemple : doc = Document().

from [Link] import Pt, Inches

 Pt : Sert à définir des tailles de police en points (Pt(12) pour une police de 12 pt).
 Inches : Sert à définir des longueurs (comme les marges ou tailles d’image) en pouces
(Inches(2.0) pour 2 pouces).

from [Link] import WD_TABLE_ALIGNMENT

 But : Importe une énumération pour gérer l’alignement des tableaux dans un document
Word.
 Exemple : [Link] = WD_TABLE_ALIGNMENT.CENTER pour centrer un tableau.

import os

 But : Importe le module os, utilisé pour interagir avec le système d’exploitation (création
de dossiers, accès à des fichiers, chemins, etc.).
 Exemple : [Link](), [Link]().

import sys

 But : Importe le module sys, qui permet d’interagir avec l’interpréteur Python (accès aux
arguments de la ligne de commande, fermeture du programme avec [Link](), etc.).
 Étape Action
Créer fenêtre cachée [Link]()
Créer Toplevel Fenêtre personnalisée (sans barre de titre)
Centrage Calcul de x, y
Dessin splash Fond + texte
Apparition progressive fade_in() avec alpha de 0 → 1
Pause 2 secondes à opacité maximale
Disparition fade_out() avec alpha de 1 → 0
Fin Affiche fenêtre principale + exécute callback

Voici une explication ligne par ligne de ce bloc de code qui définit une classe SplashScreen en
Tkinter, utilisée pour afficher un écran de démarrage animé (fade in/out) avant de lancer
l’application principale.

Déclaration de la classe
class SplashScreen:

 Déclare une classe appelée SplashScreen, qui gère l'affichage d'un écran de démarrage
graphique.
Initialisation (__init__)
def __init__(self, root, callback):

 Méthode spéciale qui s'exécute à la création d'une instance.

 root : la fenêtre principale Tkinter.
 callback : une fonction qui sera appelée après la fermeture de l'écran de démarrage (pour
démarrer l'interface principale).

[Link] = root
[Link] = callback
[Link]()

 Stocke la fenêtre principale dans [Link].

 Stocke la fonction callback.
 withdraw() cache temporairement la fenêtre principale pour ne pas l’afficher pendant le
splash screen.

Création de la fenêtre du splash screen

[Link] = [Link](root)

 Crée une nouvelle fenêtre au-dessus de root.

[Link](True)

 Supprime la barre de titre et les boutons de la fenêtre (fermer, agrandir, etc.) pour une
apparence personnalisée.

Centrage de la fenêtre splash

screen_width = [Link].winfo_screenwidth()
screen_height = [Link].winfo_screenheight()
splash_width = 800
splash_height = 600

 Récupère la taille de l'écran pour centrer la fenêtre.

 Définit la taille du splash screen à 800x600 pixels.

x = (screen_width - splash_width) // 2
y = (screen_height - splash_height) // 2

 Calcule les coordonnées x, y pour centrer la fenêtre à l'écran.

[Link](f"{splash_width}x{splash_height}+{x}+{y}")

 Définit la position et la taille de la fenêtre.

Ajout d’un canvas pour le design

[Link] = [Link]([Link], width=splash_width, height=splash_height,
highlightthickness=0)
[Link](fill="both", expand=True)

 Crée un Canvas pour dessiner des éléments (fond coloré, texte).

 highlightthickness=0 supprime la bordure.

Dessin des éléments graphiques

try:
[Link].create_rectangle(0, 0, splash_width, splash_height,
fill="#1e3c72", outline="")

 Dessine un fond bleu foncé sur tout le canvas.

[Link].create_text(splash_width//2, splash_height//2 - 50,

text="GENIE CIVIL (ESP)",
fill="white",
font=('Helvetica', 24, 'bold'))

 Affiche le texte principal centré horizontalement, un peu au-dessus du centre vertical.

[Link].create_text(splash_width//2, splash_height//2 + 20,

text="BATIMENT",
fill="white",
font=('Helvetica', 36, 'bold'))

 Affiche un deuxième texte plus grand, légèrement en dessous du centre.

except Exception as e:
print(f"Error loading splash screen: {e}")

 Gère les erreurs d’affichage.

Initialisation de l’animation (fondu)

[Link] = 0.0
self.fade_in()

 alphareprésente l’opacité (0 = invisible, 1 = totalement visible).

 Démarre l’animation d’apparition (fade_in()).

Méthode fade_in – animation de fondu entrant

def fade_in(self):

 Méthode récursive qui augmente progressivement l'opacité.

if [Link] < 1.0:

[Link] += 0.05
[Link]("-alpha", [Link])
[Link](50, self.fade_in)

 Tant que l’opacité n’est pas totale, on l’augmente par pas de 0.05.
 after(50, self.fade_in) attend 50 ms avant de rappeler fade_in().

else:
[Link](2000, self.fade_out)

 Une fois totalement visible, attend 2 secondes avant de lancer le fondu sortant.

Méthode fade_out – animation de fondu sortant

def fade_out(self):

 Diminue progressivement l'opacité jusqu’à disparition.

if [Link] > 0.0:

[Link] -= 0.05
[Link]("-alpha", [Link])
[Link](50, self.fade_out)

 Réduit l’opacité toutes les 50 ms.

else:
[Link]()
[Link]()
[Link]()

 Quand le splash est totalement invisible :

o Il est détruit (destroy()).
o La fenêtre principale est ré-affichée (deiconify()).
 o La fonction callback() est appelée (souvent : ouverture de l'interface principale).

CREATION DE L’INTERFACE

🎯 Objectif :

Créer une application Tkinter avec deux panneaux principaux :

 📥 Un panneau pour saisir les paramètres d’entrée du calcul de l’effet du vent.

 📊 Un panneau pour afficher les résultats.

🧱 Structure générale :

 Fenêtre principale (root) :

o Titre, taille (1000x600), couleur de fond (#1e3c72).
o Utilisation du système de styles ttk pour harmoniser l'apparence (couleurs,
polices, etc.).
 Cadre principal (main_frame) :
o Contient deux sections :
 left_frame : Entrées utilisateur, avec barre de défilement (scroll).
 right_frame : Affichage des résultats.
🔽 Partie gauche (Entrées) :

 Créée avec un LabelFrame intitulé "PARAMÈTRES D'ENTRÉE".

 Utilise un Canvas + Scrollbar pour permettre le défilement vertical des champs.
 Un Frame interne (scrollable_frame) est placé dans le Canvas pour recevoir
dynamiquement les champs de saisie.

📈 Partie droite (Résultats) :

 Un autre LabelFrame intitulé "RÉSULTATS".

 Destiné à afficher les résultats des calculs après validation.

🎨 Style personnalisé ([Link]) :

 Couleurs harmonisées (fond bleu foncé, texte blanc).

 Polices adaptées : Helvetica, taille 10 ou 12, parfois en gras.
 Résultats affichés sur fond blanc avec texte noir.

Voici une explication ligne par ligne du code de la classe EffetVentProApp, qui constitue une
interface graphique Tkinter destinée à l’étude des effets du vent sur une structure :

🔷 Déclaration de la classe
class EffetVentProApp:

 Déclare une classe appelée EffetVentProApp, qui représente l’application principale.

🔷 Méthode __init__ : initialisation de l’interface

def __init__(self, root):

 Méthode d’initialisation, appelée à la création de l’objet. Elle reçoit root, la fenêtre

principale Tkinter.

[Link] = root
  Enregistre la fenêtre principale dans un attribut.

[Link]("Etude et code de calcule effet du vent")

 Définit le titre affiché dans la barre de la fenêtre.

[Link]("1000x600")

 Fixe la taille de la fenêtre : 1000 pixels de large, 600 de haut.

[Link](bg="#1e3c72")

 Change la couleur de fond de la fenêtre avec un bleu foncé (#1e3c72).

🔷 Configuration des styles avec [Link]()

[Link] = [Link]()

 Initialise un objet de style pour personnaliser les composants ttk.

[Link]("TFrame", background="#1e3c72")

 Définit le fond des cadres [Link] à bleu foncé.

[Link]("TLabel", background="#1e3c72", foreground="white",

font=('Helvetica', 10))

 Style des étiquettes (Label) normales : texte blanc, fond bleu, police Helvetica 10 pt.

[Link]("TButton", font=('Helvetica', 10), padding=5)

 Style des boutons : police Helvetica 10 pt, avec un peu de marge intérieure (padding).

[Link]("[Link]", font=('Helvetica', 12, 'bold'),

foreground="white")

 Style pour les étiquettes d’en-tête : texte en gras, taille 12, couleur blanche.

[Link]("[Link]", background="white", foreground="black")

 Style pour afficher les résultats : fond blanc, texte noir.

self.setup_ui()

 Appelle la méthode setup_ui() pour construire l’interface utilisateur.

🔷 Méthode setup_ui : structure de l’interface graphique
def setup_ui(self):

 Début de la méthode de configuration de l’interface utilisateur.

main_frame = [Link]([Link])
main_frame.pack(fill=[Link], expand=True, padx=10, pady=10)

 Crée un cadre principal pour contenir les autres éléments.

 fill=[Link] + expand=True : occupe tout l’espace disponible.
 padx, pady : marges extérieures de 10 px.

🔹 Cadres gauche et droite

left_frame = [Link](main_frame, text="PARAMÈTRES D'ENTRÉE",
padding=10)
left_frame.pack(side=[Link], fill=[Link], expand=True, padx=5, pady=5)

 Cadre gauche avec un titre : pour les paramètres d’entrée.

 padding=10 ajoute de l’espace interne.
 pack à gauche, occupe toute la hauteur et largeur disponible.

right_frame = [Link](main_frame, text="RÉSULTATS", padding=10)

right_frame.pack(side=[Link], fill=[Link], expand=True, padx=5, pady=5)

 Cadre droit pour afficher les résultats du calcul.

🔹 Scrollable Canvas dans left_frame

canvas = [Link](left_frame, bg="#1e3c72", highlightthickness=0)

 Crée un Canvas à l’intérieur du left_frame, pour permettre le défilement vertical.

 highlightthickness=0 supprime la bordure grise par défaut.

scrollbar = [Link](left_frame, orient="vertical", command=[Link])

 Barre de défilement verticale liée au Canvas.

self.scrollable_frame = [Link](canvas)

 Crée un cadre interne dans le canvas, où seront ajoutés les champs de saisie dynamiques.
self.scrollable_frame.bind("<Configure>", lambda e:
[Link](scrollregion=[Link]("all")))

 Met à jour la zone défilable du canvas dès que la taille du contenu change.

canvas.create_window((0, 0), window=self.scrollable_frame, anchor="nw")

 Intègre scrollable_frame dans le Canvas, en haut à gauche (nw = North-West).

[Link](yscrollcommand=[Link])

 Connecte la scrollbar au canvas pour synchroniser le défilement.

[Link](side="left", fill="both", expand=True)

[Link](side="right", fill="y")

 Affiche le canvas à gauche (dans left_frame) et la scrollbar à droite, avec

remplissage vertical (fill="y").

Ce code génère dynamiquement une liste d’étiquettes + champs de saisie alignés en colonnes,
initialise chaque champ à "0.0", et garde une référence aux champs dans un dictionnaire pour un
accès simple.
Voici l’explication ligne par ligne de ce bout de code qui crée des champs de saisie dans
l’interface :

self.input_fields = {}

 Initialise un dictionnaire vide qui servira à stocker les widgets Entry (champs de saisie)
avec des clés faciles à utiliser (ex: "L", "rho").

labels = [
("Longueur [m]", "L"),
("Largeur [m]", "l"),
("Hauteur [m]", "h"),
("Vb0 [km/h]", "Vb_0"),
("Cdir", "Cdir"),
("Cseason", "Cseason"),
("ρ [kg/m³]", "rho"),
("z0", "z0"),
("Co", "Co"),
("kr", "kr"),
("Ki", "Ki"),
("Cpi", "Cpi"),
("Cpe", "Cpe")
]

 Définit une liste de tuples, chaque tuple contenant :

o Le texte à afficher comme étiquette (ex: "Longueur [m]"),
o Une clé (identifiant) pour référencer plus tard le champ correspondant (ex: "L").

for i, (label_text, key) in enumerate(labels):

 Boucle sur chaque élément de la liste labels avec :

o i : l’indice (0, 1, 2, ...),
o label_text : le texte de l’étiquette,
o key : la clé identifiant le champ.

lbl = [Link](self.scrollable_frame, text=label_text)

 Crée un widget Label dans le scrollable_frame avec le texte donné (ex : "Longueur
[m]").

[Link](row=i, column=0, sticky="w", pady=2, padx=5)

 Place ce label dans une grille :

o Ligne i,
o Colonne 0 (colonne de gauche),
 o Aligné à gauche (sticky="w"),
o Avec un peu d’espace autour (pady=2, padx=5).

entry = [Link](self.scrollable_frame)

 Crée un champ de saisie (Entry) dans le même cadre.

[Link](0, "0.0")

 Remplit ce champ par défaut avec la chaîne "0.0".

[Link]("<FocusIn>", lambda e: self.clear_default_text(e))

 Ajoute un événement : quand on clique dans le champ (événement <FocusIn>),

 Appelle la méthode clear_default_text(e) (probablement pour effacer le "0.0" dès
que l’utilisateur commence à saisir).

[Link](row=i, column=1, sticky="ew", pady=2, padx=5)

 Place ce champ de saisie à côté du label dans la grille :

o Même ligne i,
o Colonne 1 (à droite du label),
o Remplit horizontalement (sticky="ew"),
o Avec marges verticales et horizontales (pady=2, padx=5).

self.input_fields[key] = entry

 Enregistre le champ dans le dictionnaire self.input_fields sous la clé correspondante

(ex: self.input_fields["L"] = entry),
 Cela permet ensuite de récupérer facilement la valeur saisie via cette clé.
Ce code crée une liste de résultats affichés sous forme de paires texte + valeur vide. Le
dictionnaire self.result_labels permet ensuite de mettre à jour facilement les valeurs
affichées dans l’interface (par exemple après calcul).

Voici l’explication détaillée ligne par ligne de ce code qui crée les étiquettes pour afficher les
résultats dans l’interface :

self.result_labels = {}

 Initialise un dictionnaire vide pour stocker les widgets Label qui afficheront les
résultats, accessibles par des clés (ex: "Vb").

result_vars = [
("Vb [km/h]", "Vb"),
("qb [kN/m²]", "qb"),
("Cr", "Cr"),
("Vm [km/h]", "Vm"),
("Iv", "Iv"),
("qp(z) [kN/m²]", "qpz"),
("W [kN/m²]", "W")
]

 Définit une liste de tuples, chaque tuple contenant :

o Le texte à afficher à gauche (ex: "Vb [km/h]"),
o Une clé pour référencer plus tard le label qui affichera la valeur (ex: "Vb").

for i, (text, key) in enumerate(result_vars):

  Parcourt cette liste avec un indice i et décompose chaque tuple en text (texte à afficher)
et key (clé d’identification).

[Link](right_frame, text=text).grid(row=i, column=0, sticky="w", pady=2,

padx=5)

 Crée un widget Label dans le right_frame (zone des résultats) avec le texte donné,
 Le place dans une grille, ligne i, colonne 0 (à gauche),
 Aligné à gauche (sticky="w") avec un petit espace autour (pady=2, padx=5).

self.result_labels[key] = [Link](right_frame, text="",

style="[Link]", width=20)

 Crée un autre label, cette fois vide (text=""),

 Ce label aura un style particulier ("[Link]") qui lui donne un fond blanc et texte
noir,
 Définit une largeur fixe (20 caractères) pour que tous aient la même taille,
 Stocke ce label dans le dictionnaire self.result_labels sous la clé associée.

self.result_labels[key].grid(row=i, column=1, sticky="e", pady=2, padx=5)

 Place ce label vide à droite du texte descriptif (colonne 1),

 Aligné à droite (sticky="e"),
 Avec les mêmes marges verticales et horizontales (pady=2, padx=5).
Ce code construit une barre de boutons centrée avec trois boutons (CALCULER, EFFACER, AIDE),
organise la mise en page pour un bon redimensionnement des colonnes, et prépare un dossier sur
le disque pour sauvegarder des résultats.

Voici l'explication ligne par ligne de ce code qui crée un ensemble de boutons et configure
certaines propriétés de mise en page dans Tkinter :

button_frame = [Link]([Link])

 Crée un cadre (Frame) dans la fenêtre principale ([Link]) qui va contenir les boutons.

button_frame.pack(fill=tk.X, padx=10, pady=10)

 Place ce cadre dans la fenêtre principale en le faisant s’étendre horizontalement

(fill=tk.X),
 Ajoute un espace autour du cadre : 10 pixels à gauche/droite (padx=10) et en haut/bas
(pady=10).

center_frame = [Link](button_frame)

 Crée un sous-cadre à l’intérieur de button_frame.

 Ce sous-cadre servira à centrer les boutons.

center_frame.pack(expand=True)

 Place ce sous-cadre dans button_frame en lui demandant d’occuper tout l’espace

disponible (expand=True),
 Par défaut, il s’étendra autant que possible dans son conteneur.

btn_calculer = [Link](center_frame, text="CALCULER",

command=[Link])

 Crée un bouton nommé "CALCULER" dans center_frame,

 Le bouton exécutera la méthode [Link] lorsqu'on clique dessus.

btn_calculer.pack(side=[Link], padx=5)

 Place ce bouton dans center_frame,

  Positionné à gauche (side=[Link]),
 Avec un petit espace horizontal (5 pixels) à gauche et à droite (padx=5).

btn_effacer = [Link](center_frame, text="EFFACER", command=[Link])

 Crée un bouton "EFFACER" dans center_frame qui appelle la méthode [Link] au

clic.

btn_effacer.pack(side=[Link], padx=5)

 Place ce bouton à gauche dans center_frame, à côté du précédent, avec un espacement

horizontal.

btn_aide = [Link](center_frame, text="AIDE", command=self.afficher_aide)

 Crée un bouton "AIDE" dans center_frame qui déclenche la méthode

self.afficher_aide au clic.

btn_aide.pack(side=[Link], padx=5)

 Place ce bouton à gauche dans center_frame, après les deux premiers, avec un
espacement horizontal.

self.scrollable_frame.columnconfigure(1, weight=1)

 Configure la colonne 1 (deuxième colonne) de self.scrollable_frame pour qu’elle

puisse s’étendre et prendre tout l’espace disponible horizontalement (weight=1).

right_frame.columnconfigure(1, weight=1)

 Configure la colonne 1 de right_frame (zone des résultats) de la même manière, pour

que cette colonne puisse s’étirer horizontalement.

main_frame.columnconfigure(0, weight=1)
main_frame.columnconfigure(1, weight=1)

 Configure les colonnes 0 et 1 de main_frame (cadre principal) pour qu’elles se partagent

l’espace horizontal également (poids 1 chacune).

[Link]("Resultats_Vent", exist_ok=True)
  Crée un dossier nommé "Resultats_Vent" dans le répertoire courant si ce dossier
n’existe pas encore (exist_ok=True empêche une erreur si le dossier existe déjà).
 Ce dossier servira probablement à sauvegarder les résultats.

 clear_default_text vide un champ texte s’il contient la valeur par défaut "0.0" quand
on clique dedans,
 parse_float convertit une chaîne en nombre décimal, en gérant le cas où la chaîne est
mal formée ou utilise une virgule comme séparateur décimal.

Voici l’explication ligne par ligne de ce code Python, qui définit deux méthodes :

def clear_default_text(self, event):

 Définition d’une méthode clear_default_text qui prend un argument event.

 Cette méthode est conçue pour être appelée lorsqu’un événement (comme un clic dans un
champ texte) survient.

if [Link]() == "0.0":

 Récupère le contenu actuel du widget (champ de saisie) qui a généré l’événement

([Link]),
 Vérifie si ce contenu est exactement la chaîne "0.0" (valeur par défaut initiale).
[Link](0, [Link])

 Si le contenu est "0.0", alors on supprime tout le texte du widget,

 0 est la position de départ (début du champ),
 [Link] est la position finale (fin du champ),
 Ce qui vide complètement le champ de saisie.

def parse_float(self, val):

 Définition d’une méthode parse_float qui prend une chaîne de caractères val en
argument.
 Cette méthode va tenter de convertir la chaîne en nombre flottant.

try:
return float([Link](',', '.'))

 Essaie d’exécuter ce bloc :

o Remplace les virgules , par des points . dans la chaîne (utile si l’utilisateur utilise
la virgule comme séparateur décimal),
o Convertit ensuite la chaîne modifiée en nombre flottant float(),
o Retourne ce nombre.

except:
return 0.0

 Si la conversion échoue (ex: la chaîne n’est pas un nombre valide),

 La méthode renvoie la valeur par défaut 0.0 sans faire planter le programme.

 clear_default_text vide un champ texte s’il contient la valeur par défaut "0.0" quand
on clique dedans,
 parse_float convertit une chaîne en nombre décimal, en gérant le cas où la chaîne est
mal formée ou utilise une virgule comme séparateur décimal.
Cette méthode récupère toutes les entrées utilisateur, effectue les calculs physiques liés à l’effet
du vent (vitesse, pression, charge), affiche les résultats dans l’interface, sauvegarde ces résultats,
et gère proprement les erreurs.

Voici l'explication ligne par ligne de cette méthode calculer(self), qui réalise des calculs
physiques liés à l'effet du vent et affiche les résultats :

def calculer(self):

 Définition de la méthode calculer dans une classe.

 Cette méthode sera appelée pour effectuer tous les calculs.

try:

 Démarre un bloc try pour capturer et gérer proprement d’éventuelles erreurs lors des
calculs.

params = {k: self.parse_float([Link]()) for k, v in self.input_fields.items()}

 Crée un dictionnaire params où :

o Pour chaque clé k et champ de saisie v dans self.input_fields (les champs
d’entrée),
o On récupère la valeur du champ ([Link]()), la convertit en float via
self.parse_float(),
o On stocke le résultat sous la clé k dans params.
Vb0_ms = params["Vb_0"] / 3.6

 Convertit la vitesse initiale du vent Vb_0 de km/h en m/s (car 1 km/h = 1/3.6 m/s).

Vb = Vb0_ms * params["Cdir"] * params["Cseason"]

 Calcule la vitesse du vent corrigée Vb en multipliant la vitesse de base Vb0_ms par les
coefficients directionnel (Cdir) et saisonnier (Cseason).

qb = 0.5 * params["rho"] * (Vb ** 2) / 1000

 Calcule la pression dynamique du vent qb (en kN/m²) :

qb=12×ρ×Vb2qb = \frac{1}{2} \times \rho \times Vb^2
Le résultat est divisé par 1000 pour convertir les unités.

Cr = params["kr"] * [Link](params["h"] / params["z0"]) if params["z0"] > 0

else 0

 Calcule le coefficient Cr lié à la rugosité et la hauteur :

o Si z0 > 0, alors
Cr=kr×ln⁡(hz0)\text{Cr} = kr \times \ln(\frac{h}{z0})
o Sinon Cr = 0 pour éviter une erreur mathématique (logarithme de zéro ou
négatif).

Vm = Vb * Cr

 Calcule la vitesse modifiée Vm en multipliant Vb par Cr.

Iv = params["Ki"] / [Link](params["h"] / params["z0"]) if params["z0"] > 0

else 0

 Calcule l’intensité de la turbulence Iv :

o Si z0 > 0, alors
Iv=Kiln⁡(hz0)\text{Iv} = \frac{Ki}{\ln(\frac{h}{z0})}
o Sinon Iv = 0.

qpz = qb * (1 + 7 * Iv) * (Cr ** 2)

 Calcule la pression dynamique corrigée qpz en fonction de qb, de l’intensité de turbulence

Iv et du carré de Cr.
W = qpz * abs(params["Cpe"] - params["Cpi"])

 Calcule la charge du vent W en fonction de la pression dynamique corrigée qpz et la

différence absolue des coefficients de pression externe (Cpe) et interne (Cpi).

Vb_kmh = Vb * 3.6
Vm_kmh = Vm * 3.6

 Convertit Vb et Vm de m/s en km/h (multiplication par 3.6) pour affichage.

self.result_labels["Vb"].config(text=f"{Vb_kmh:.2f}")
self.result_labels["qb"].config(text=f"{qb:.4f}")
self.result_labels["Cr"].config(text=f"{Cr:.4f}")
self.result_labels["Vm"].config(text=f"{Vm_kmh:.2f}")
self.result_labels["Iv"].config(text=f"{Iv:.4f}")
self.result_labels["qpz"].config(text=f"{qpz:.4f}")
self.result_labels["W"].config(text=f"{W:.4f}")

 Met à jour les labels de résultats dans l’interface graphique avec les valeurs calculées
formatées avec un certain nombre de décimales.

self.sauvegarder_resultats({
"Vb (km/h)": Vb_kmh,
"qb (kN/m²)": qb,
"Cr": Cr,
"Vm (km/h)": Vm_kmh,
"Iv": Iv,
"qp(z) (kN/m²)": qpz,
"W (kN/m²)": W
})

 Appelle une méthode sauvegarder_resultats en lui passant un dictionnaire des

résultats à sauvegarder (par exemple dans un fichier).

except Exception as e:

 Capture toute exception qui pourrait survenir pendant le calcul.

[Link]("Erreur", f"Une erreur est survenue:\n{str(e)}")

 Affiche une boîte de dialogue d’erreur avec le message de l’exception pour informer
l’utilisateur.
print(f"Erreur détaillée: {str(e)}", file=[Link])

 Imprime le message d’erreur détaillé dans la sortie d’erreur standard (console), utile pour
le débogage.

Cette méthode crée (ou ouvre) un fichier Word nommé resultats_calculs.docx dans un
dossier Resultats_Vent. Elle y ajoute une page avec :

 un titre,
 la date du calcul,
 un tableau listant tous les paramètres d'entrée,
 un autre tableau listant tous les résultats du calcul,
avant de sauvegarder le document. Elle gère aussi les erreurs pour ne pas planter le
programme.

Voici une explication détaillée ligne par ligne de cette fonction sauvegarder_resultats(self,
results), qui sert à enregistrer dans un fichier Word les paramètres d’entrée et les résultats des
calculs :

def sauvegarder_resultats(self, results):

 Déclaration de la méthode sauvegarder_resultats avec un argument results (un

dictionnaire contenant les résultats à sauvegarder).
try:

 Début d’un bloc try pour gérer proprement les erreurs éventuelles lors de la sauvegarde.

script_dir = [Link]([Link] if getattr(sys, 'frozen', False)

else [Link](__file__))

 Détermine le dossier du script en cours d’exécution :

o Si le programme est « congelé » (packagé en exécutable, par ex. avec PyInstaller),
récupère le dossier du fichier exécutable [Link].
o Sinon, récupère le dossier du fichier .py en cours via __file__.
o [Link] extrait le chemin du dossier (sans le nom du fichier).

word_path = [Link](script_dir, "Resultats_Vent",

"resultats_calculs.docx")

 Construit le chemin complet du fichier Word à créer/sauvegarder, dans un sous-dossier

Resultats_Vent du dossier du script, nommé resultats_calculs.docx.

[Link]([Link](word_path), exist_ok=True)

 Crée le dossier Resultats_Vent s’il n’existe pas déjà (exist_ok=True évite une erreur si
le dossier existe).

if [Link](word_path):
doc = Document(word_path)
doc.add_page_break()
else:
doc = Document()
style = [Link]['Normal']
font = [Link]
[Link] = 'Arial'
[Link] = Pt(10)

 Si le fichier Word existe déjà :

o Ouvre ce fichier existant en lecture/écriture avec Document(word_path).
o Ajoute un saut de page (nouvelle page) pour séparer le nouveau contenu.
 Sinon, crée un nouveau document Word vide.
o Récupère le style Normal.
o Définit la police par défaut en Arial, taille 10 points.

doc.add_heading(f"Calcul effet du vent", level=1)

 Ajoute un titre de niveau 1 (titre principal) "Calcul effet du vent" dans le document.
doc.add_paragraph(f"Date: {[Link]().strftime('%d/%m/%Y %H:%M:%S')}")

 Ajoute un paragraphe indiquant la date et l’heure actuelles au format jour/mois/année

heure:minute:seconde.

doc.add_heading("Paramètres d'entrée", level=2)

 Ajoute un sous-titre de niveau 2 "Paramètres d'entrée" pour la section des données

d’entrée.

table_params = doc.add_table(rows=1, cols=2)

table_params.style = 'Light Grid'
table_params.autofit = True
table_params.alignment = WD_TABLE_ALIGNMENT.CENTER

 Crée un tableau Word de 1 ligne et 2 colonnes pour afficher les paramètres.

 Applique un style de tableau léger (Light Grid).
 Active l’ajustement automatique de la largeur des colonnes (autofit=True).
 Centre horizontalement le tableau.

hdr_cells = table_params.rows[0].cells
hdr_cells[0].text = "Paramètre"
hdr_cells[1].text = "Valeur"

 Dans la première ligne (en-tête), met les titres des colonnes : "Paramètre" et "Valeur".

for param, entry in self.input_fields.items():

row_cells = table_params.add_row().cells
row_cells[0].text = str(param)
row_cells[1].text = str([Link]())

 Pour chaque paramètre d’entrée et son widget dans self.input_fields :

o Ajoute une nouvelle ligne au tableau.
o Remplit la première cellule avec le nom du paramètre (param).
o Remplit la deuxième cellule avec la valeur saisie dans le champ (récupérée par
[Link]()).

doc.add_heading("Résultats du calcul", level=2)

 Ajoute un sous-titre de niveau 2 "Résultats du calcul" pour la section des résultats.

table_results = doc.add_table(rows=1, cols=2)

table_results.style = 'Light Grid'
table_results.autofit = True
table_results.alignment = WD_TABLE_ALIGNMENT.CENTER

 Crée un autre tableau pour les résultats, avec la même configuration (1 ligne, 2 colonnes,
style léger, ajustement automatique, centrage).

hdr_cells = table_results.rows[0].cells
hdr_cells[0].text = "Résultat"
hdr_cells[1].text = "Valeur"

 Définit les en-têtes du tableau des résultats.

for param, valeur in [Link]():

row_cells = table_results.add_row().cells
row_cells[0].text = str(param)
row_cells[1].text = f"{valeur:.4f}"

 Pour chaque clé (nom du résultat) et valeur dans le dictionnaire results :

o Ajoute une nouvelle ligne.
o Met le nom du résultat dans la première colonne.
o Met la valeur formatée avec 4 décimales dans la deuxième colonne.

[Link](word_path)

 Sauvegarde le document Word modifié/créé dans le chemin word_path.

except Exception as e:
print(f"Erreur lors de la sauvegarde: {str(e)}", file=[Link])

 En cas d’erreur dans le bloc try, affiche le message d’erreur dans la sortie d’erreur
standard (console).
  effacer() remet tous les champs d’entrée à "0.0" et vide les résultats affichés.
 afficher_aide() prépare un message d’instructions pour guider l’utilisateur dans
l’utilisation de l’application.

Voici l'explication ligne par ligne de ce code comportant deux méthodes effacer et
afficher_aide :

def effacer(self):

 Définition de la méthode effacer, qui sert à remettre à zéro les champs d'entrée et les
résultats affichés.

for field in self.input_fields.values():

 Pour chaque widget champ de saisie (Entry) contenu dans le dictionnaire

self.input_fields (toutes les zones où l’utilisateur entre des valeurs)...

[Link](0, [Link])

 Supprime tout le texte contenu dans ce champ, depuis le premier caractère (0) jusqu'à la
fin ([Link]).
[Link](0, "0.0")

 Insère le texte "0.0" au début du champ pour remettre une valeur par défaut.

for label in self.result_labels.values():

 Pour chaque label affichant un résultat dans self.result_labels...

[Link](text="")

 Vide le texte affiché dans ce label, donc efface les résultats affichés.

def afficher_aide(self):

 Définition de la méthode afficher_aide, qui va afficher un message d’aide à

l’utilisateur.

help_text = """INSTRUCTIONS:
1. Remplissez tous les champs de paramètres
2. Cliquez sur CALCULER pour obtenir les résultats
3. EFFACER réinitialise tous les champs
"""

 Création d’une chaîne de caractères multilignes stockée dans help_text contenant les
instructions pour l’utilisateur :
1. Remplir tous les champs
2. Cliquer sur CALCULER pour obtenir les résultats
3. EFFACER pour remettre à zéro les champs

Note : dans le bout de code donné, on ne voit pas l’affichage concret de help_text (ex: via une
fenêtre messagebox), mais l’idée est qu’elle sera utilisée pour montrer ces instructions.
  Le texte d’aide est affiché dans une boîte d’info.
 main() crée la fenêtre principale, affiche un écran de démarrage, puis lance l’application.
 Le programme démarre par l’appel à main() quand on exécute ce fichier.

Voici l’explication ligne par ligne de ce code :

UNITÉS:
- Longueurs: mètres [m]
- Vitesses: kilomètres/heure [km/h]
- Pressions: kilonewtons/mètre² [kN/m²]"""

 Ceci est la fin d’une chaîne de caractères multilignes (help_text), précisant les unités
utilisées dans l’application :
o Longueur en mètres (m)
o Vitesse en kilomètres par heure (km/h)
o Pression en kilonewtons par mètre carré (kN/m²)

[Link]("Aide", help_text)

 Affiche une boîte d’information (showinfo) avec le titre "Aide" et le contenu du texte
help_text (qui contient les instructions et unités).
 Cela montre la fenêtre d’aide à l’utilisateur.

def main():
  Définition de la fonction principale main() qui lance l’application.

root = [Link]()

 Création de la fenêtre principale Tkinter, nommée ici root.

splash = SplashScreen(root, lambda: EffetVentProApp(root))

 Création d’un écran de démarrage (splash screen) en appelant la classe SplashScreen.

 root est passé comme fenêtre parent.
 Une fonction lambda est passée en callback qui créera l’application principale
EffetVentProApp avec la fenêtre root une fois le splash terminé.

[Link]()

 Démarre la boucle principale de Tkinter, qui permet à la fenêtre de rester affichée et

réactive aux événements utilisateur.

if __name__ == '__main__':

 Condition qui vérifie si ce script est exécuté directement (pas importé comme module).

main()

 Si le script est exécuté directement, on appelle la fonction main() pour démarrer

l’application.
ETAPE DE TRANSFORMATION DES CODES PYTHON EN LOGICIEL

Transformer ce code Python Tkinter en un logiciel utilisable par d’autres (sans forcément passer
par un éditeur Python) passe par plusieurs étapes clés. Voici un plan simple pour y arriver, étape
par étape :

Étapes pour transformer ce code en logiciel

1. Finaliser et tester le code

 S’assurer que toutes les fonctionnalités marchent bien.

 Vérifier qu’il n’y a pas d’erreurs (gestion des exceptions, interface fluide).
 Tester tous les cas d’entrée possibles.

2. Créer un fichier exécutable (.exe)

 Comme ton code est en Python avec interface Tkinter, on utilise un outil pour transformer
le script en un exécutable Windows autonome.
 Outils courants :
o PyInstaller

a. Installer PyInstaller :
b. pip install pyinstaller
c. Générer l’exécutable :
d. pyinstaller --onefile --windowed ton_script.py
e. --onefile : crée un seul fichier .exe.
f. --windowed : empêche l’ouverture de la console (utile pour les GUI).

Le fichier .exe généré sera dans le dossier dist.