Informer, former & réfléchir aux défis du numérique

Outils pour utilisateurs

Outils du site

Vous êtes ici : accueil » cours_de_physique_sur_dame_blanche
Piste : • cours_de_physique_sur_dame_blanche
cours_de_physique_sur_dame_blanche

Table des matières

<markdown> # Dame Blanche - Physique Maritime ## Module 4 : Électricité statique ### Documents 6 & 7 : Simulations GeoGebra et Programmes Python

Licence : CC-BY-SA 4.0 Auteur : Nicolas Pettiaux, Athénée Royal de Ganshoren, ASBL EduCode

—

## TABLE DES MATIÈRES

DOCUMENT 6 : SIMULATIONS GEOGEBRA 1. Simulation 1 : Champ d'une charge ponctuelle 2. Simulation 2 : Superposition de deux charges 3. Simulation 3 : Configuration orage-voilier 4. Simulation 4 : Lignes de champ et surfaces équipotentielles

DOCUMENT 7 : PROGRAMMES PYTHON NUMWORKS 1. Programme 1 : Calcul force de Coulomb 2. Programme 2 : Calcul champ électrique 3. Programme 3 : Superposition de charges 4. Programme 4 : Analyse situation orage-voilier 5. Programme 5 : Graphiques E et V vs distance 6. Programme 6 : Simulation trajectoire particule chargée

—

# DOCUMENT 6 : SIMULATIONS GEOGEBRA

## Introduction

Les simulations GeoGebra permettent de visualiser les concepts abstraits d'électrostatique. Elles sont interactives : vous pouvez modifier les paramètres (charges, positions) et observer immédiatement les effets.

Accès aux fichiers : - Dépôt Framagit : https://framagit.org/dame-blanche-physique/module4-geogebra - Fichiers .ggb à télécharger et ouvrir avec GeoGebra Desktop ou Web

Mode d'emploi : 1. Ouvrir le fichier .ggb 2. Utiliser les curseurs pour modifier les paramètres 3. Observer les lignes de champ, vecteurs, valeurs calculées 4. Faire des captures d'écran pour vos comptes-rendus

—

## Simulation 1 : Champ d'une charge ponctuelle

Fichier : `champ_charge_unique.ggb`

### Objectifs pédagogiques - Visualiser le champ électrique radial créé par une charge ponctuelle - Observer la direction du champ (divergent si Q>0, convergent si Q<0) - Vérifier la décroissance en 1/r²

### Éléments de l'interface

Curseurs : - `Q` : Charge (de -10 µC à +10 µC) - `r_test` : Distance d'un point test (de 0,1 m à 2 m)

Affichage : - Charge Q représentée par un point (rouge si +, bleu si -) - Lignes de champ radiales (flèches) - Point test déplaçable - Vecteur champ $\vec{E}$ au point test (avec norme affichée) - Valeur numérique : $E = k|Q|/r^2$ en V/m

### Code GeoGebra (extraits)

``` # Constante de Coulomb k = 8.99 * 10^9

# Charge (en C) Q = Slider[-10*10^(-6), 10*10^(-6), 0.1*10^(-6)]

# Position de la charge O = (0, 0)

# Point test P = Point déplaçable

# Distance r = Distance[O, P]

# Calcul du champ E_norme = k * abs(Q) / r^2

# Direction (vecteur unitaire) u = Vector[O, P] / r

# Vecteur champ (avec échelle pour visualisation) echelle = 0.01 # ajuster pour lisibilité E_vecteur = If[Q > 0, echelle * E_norme * u, -echelle * E_norme * u]

# Lignes de champ (16 lignes radiales) For[i, 0, 15]: 

  angle = i * 2π / 16
  direction = If[Q > 0, 1, -1]
  Ligne[O, direction * (cos(angle), sin(angle))]

End ```

### Activités suggérées

1. Exploration qualitative (5 min)

  1. Modifier Q de -10 à +10 µC
  2. Observer l'inversion des lignes de champ
  3. Noter : lignes vers l'extérieur si Q>0, vers l'intérieur si Q<0

2. Vérification quantitative (10 min)

  1. Fixer Q = +5 µC
  2. Déplacer le point test à r = 0,5 m, 1 m, 1,5 m, 2 m
  3. Noter E pour chaque distance
  4. Calculer manuellement et comparer
r (m) E mesuré (V/m) E calculé = kQ/r² Écart (%)
——-—————-——————————–
0,5
1,0
1,5
2,0

3. Graphique E vs 1/r² (15 min)

  1. Relever E pour 10 valeurs de r entre 0,2 et 2 m
  2. Tracer E en fonction de 1/r²
  3. Vérifier la linéarité (régression linéaire)
  4. La pente doit être k|Q|

—

## Simulation 2 : Superposition de deux charges

Fichier : `superposition_deux_charges.ggb`

### Objectifs pédagogiques - Comprendre le principe de superposition - Visualiser l'addition vectorielle des champs - Observer les configurations dipôle, deux charges de même signe

### Éléments de l'interface

Curseurs : - `Q1` : Première charge (de -10 µC à +10 µC) - `Q2` : Deuxième charge (de -10 µC à +10 µC) - `d` : Distance entre les charges (de 0,2 m à 2 m)

Points déplaçables : - Position de Q1 (fixe ou déplaçable selon version) - Position de Q2 (sur axe x, distance d de Q1) - Point test P

Affichage : - Les deux charges Q1 et Q2 - Lignes de champ résultantes (calcul numérique) - Vecteurs $\vec{E_1}$ et $\vec{E_2}$ au point P - Vecteur $\vec{E_{total}} = \vec{E_1} + \vec{E_2}$ - Valeurs numériques : $E_1$, $E_2$, $E_{total}$ en V/m

### Code GeoGebra (extraits)

``` # Charges Q1 = Slider[-10e-6, 10e-6, 0.1e-6] Q2 = Slider[-10e-6, 10e-6, 0.1e-6] d = Slider[0.2, 2, 0.1]

# Positions A = (-d/2, 0) # Q1 à gauche B = (d/2, 0) # Q2 à droite

# Point test P = Point déplaçable

# Distances r1 = Distance[A, P] r2 = Distance[B, P]

# Champs individuels (normes) E1_norme = k * abs(Q1) / r1^2 E2_norme = k * abs(Q2) / r2^2

# Vecteurs unitaires u1 = Vector[A, P] / r1 u2 = Vector[B, P] / r2

# Vecteurs champs E1_vecteur = If[Q1 > 0, E1_norme * u1, -E1_norme * u1] E2_vecteur = If[Q2 > 0, E2_norme * u2, -E2_norme * u2]

# Champ total (addition vectorielle) E_total = E1_vecteur + E2_vecteur E_total_norme = Length[E_total]

# Lignes de champ (calcul numérique par intégration) # [Code plus complexe, voir fichier .ggb] ```

### Activités suggérées

1. Configuration dipôle (15 min)

  1. Régler Q1 = +5 µC, Q2 = -5 µC, d = 0,5 m
  2. Observer les lignes de champ (partent de + vers -)
  3. Déplacer P le long de l'axe des x
  4. Trouver le point où E est maximal (entre les charges)
  5. Trouver les points où E = 0 (aucun !)

2. Deux charges positives (10 min)

  1. Régler Q1 = Q2 = +3 µC, d = 0,5 m
  2. Observer la répulsion (lignes s'écartent)
  3. Trouver le point milieu : E = 0 (par symétrie)

3. Recherche de points d'équilibre (20 min)

  1. Q1 = +10 µC, Q2 = -5 µC, d = 0,6 m
  2. Chercher les points où $E_{total} = 0$
  3. Il y en a sur l'axe des x, à l'extérieur du segment [Q1, Q2]
  4. Calculer analytiquement et vérifier graphiquement

—

## Simulation 3 : Configuration orage-voilier

Fichier : `orage_voilier.ggb`

### Objectifs pédagogiques - Application maritime concrète - Géométrie 2D (distance oblique nuage-mât) - Calcul du champ au sommet du mât - Évaluation du risque de foudre

### Éléments de l'interface

Curseurs : - `Q_nuage` : Charge du nuage (de -100 C à 0 C) - `h_nuage` : Altitude du nuage (de 1000 m à 3000 m) - `d_horiz` : Distance horizontale (de 0 m à 2000 m)

Paramètres fixes : - `h_mat` = 11 m (hauteur du mât de Dame Blanche)

Affichage graphique : - Échelle verticale : altitude (m) - Échelle horizontale : distance (m) - Mer (niveau 0) - Voilier Dame Blanche (schématique) - Mât vertical jusqu'à 11 m - Nuage orageux à altitude h_nuage - Ligne pointillée : distance r entre nuage et sommet du mât

Calculs affichés : - Distance réelle : $r = \sqrt{(h_{nuage} - h_{mat})^2 + d_{horiz}^2}$ - Champ au sommet : $E = k|Q_{nuage}|/r^2$ en kV/m - Potentiel au sommet : $V = kQ_{nuage}/r$ en MV - Énergie éclair (avec I=40 kA, Δt=0,2 ms) : en GJ - Pourcentage du seuil de claquage : $E/3000$ kV/m × 100%

Code couleur du risque : - Vert : E < 50 kV/m (risque faible) - Orange : 50 < E < 100 kV/m (risque modéré) - Rouge : E > 100 kV/m (risque élevé)

### Code GeoGebra (extraits)

``` # Paramètres Q_nuage = Slider[-100, 0, 1] # en C h_nuage = Slider[1000, 3000, 100] # en m d_horiz = Slider[0, 2000, 100] # en m h_mat = 11 # m

# Distance réelle r = sqrt1) * 1e-6 q2 = float(input(“Charge q2 (en µC) : ”)) * 1e-6 r = float(input(“Distance r (en cm) : ”)) / 100

F = coulomb(q1, q2, r) sens = sens_force(q1, q2)

print(“”) print(“Résultats :”) print(f“Force : F = {F:.4f} N”) print(f“Sens : {sens}”)

# Comparaison avec poids m_equiv = F / 9.81 print(f“Équivalent : poids de {m_equiv*1000:.2f} g”) ```

### Exemple d'utilisation

```

Force de Coulomb

Charge q1 (en µC) : 3.5 Charge q2 (en µC) : -2.0 Distance r (en cm) : 15

Résultats : Force : F = 2.7973 N Sens : Attraction Équivalent : poids de 285.16 g ```

—

## Programme 2 : Calcul champ électrique

Fichier : `champ.py`

### Code complet

```python “”“ Dame Blanche - Module 4 : Électricité statique Programme 2 : Calcul du champ électrique ”“”

def champ_electrique(Q, r): 

  """
  Calcule le champ électrique créé par une charge ponctuelle.
  
  Paramètres:
      Q : charge (C)
      r : distance (m)
  
  Retourne:
      E : champ électrique (V/m)
  """
  k = 8.99e9
  E = k * abs(Q) / r**2
  return E

def direction_champ(Q): 

  """
  Indique la direction du champ.
  
  Retourne:
      "Divergent" (Q>0) ou "Convergent" (Q<0)
  """
  if Q > 0:
      return "Divergent (vers l'extérieur)"
  else:
      return "Convergent (vers la charge)"

# Interface print(“=== Champ Électrique ===”) print(“”)

Q = float(input(“Charge Q (en µC) : ”)) * 1e-6 r = float(input(“Distance r (en m) : ”))

E = champ_electrique(Q, r) direction = direction_champ(Q)

print(“”) print(“Résultats :”) print(f“Champ : E = {E:.2e} V/m”) print(f“ E = {E/1000:.2f} kV/m”) print(f“Direction : {direction}”)

# Comparaison champ atmosphérique E_atm = 100 # V/m ratio = E / E_atm print(f“Comparaison : {ratio:.1f} fois le champ atmosphérique”) ```

—

## Programme 3 : Superposition de charges

Fichier : `superposition.py`

### Code complet

```python “”“ Dame Blanche - Module 4 : Électricité statique Programme 3 : Superposition de charges ”“”

from math import sqrt

def superposition(charges, positions, point): 

  """
  Calcule le champ électrique résultant de plusieurs charges.
  
  Paramètres:
      charges : liste de charges [q1, q2, ...] (C)
      positions : liste de tuples [(x1,y1), (x2,y2), ...] (m)
      point : tuple (x, y) où calculer le champ (m)
  
  Retourne:
      (Ex, Ey, E_total) : composantes et norme (V/m)
  """
  k = 8.99e9
  Ex, Ey = 0, 0
  
  for q, (xq, yq) in zip(charges, positions):
      # Vecteur déplacement
      dx = point[0] - xq
      dy = point[1] - yq
      r = sqrt(dx**2 + dy**2)
      
      # Éviter division par zéro
      if r < 1e-10:
          continue
      
      # Norme du champ créé par cette charge
      E_mag = k * abs(q) / r**2
      
      # Composantes (selon signe de q)
      signe = 1 if q > 0 else -1
      Ex += E_mag * (dx / r) * signe
      Ey += E_mag * (dy / r) * signe
  
  E_total = sqrt(Ex**2 + Ey**2)
  return Ex, Ey, E_total

# Interface - Exemple : 3 charges alignées print(“=== Superposition de Charges ===”) print(“Exemple : 3 charges alignées sur x”) print(“”)

# Saisie q1 = float(input(“Q1 (µC) en x1=0 : ”)) * 1e-6 q2 = float(input(“Q2 (µC) en x2=0.6 : ”)) * 1e-6 q3 = float(input(“Q3 (µC) en x3=1.2 : ”)) * 1e-6 xp = float(input(“Point P à x = (m) : ”))

# Calcul charges = [q1, q2, q3] positions = [(0, 0), (0.6, 0), (1.2, 0)] point = (xp, 0)

Ex, Ey, E_total = superposition(charges, positions, point)

# Affichage print(“”) print(“Résultats :”) print(f“Ex = {Ex:.2e} V/m”) print(f“Ey = {Ey:.2e} V/m”) print(f“E total = {E_total:.2e} V/m”) print(f“E total = {E_total/1000:.2f} kV/m”)

# Direction if abs(Ex) > 1: 

  if Ex > 0:
      print("Direction : vers la droite (+x)")
  else:
      print("Direction : vers la gauche (-x)")

```

—

## Programme 4 : Analyse situation orage-voilier

Fichier : `orage_voilier.py`

### Code complet

```python “”“ Dame Blanche - Module 4 : Électricité statique Programme 4 : Analyse complète orage-voilier ”“”

from math import sqrt

def analyse_orage(Q_nuage, h_nuage, d_horiz, h_mat=11): 

  """
  Analyse complète d'une situation orageuse pour Dame Blanche.
  
  Paramètres:
      Q_nuage : charge du nuage (C, négatif)
      h_nuage : altitude du nuage (m)
      d_horiz : distance horizontale (m)
      h_mat : hauteur du mât (m, défaut=11)
  
  Retourne:
      Dictionnaire avec tous les résultats
  """
  k = 8.99e9
  
  # Distance réelle
  r = sqrt((h_nuage - h_mat)**2 + d_horiz**2)
  
  # Champ au sommet du mât
  E = k * abs(Q_nuage) / r**2
  E_kV = E / 1000
  
  # Potentiel
  V = k * Q_nuage / r
  V_MV = V / 1e6
  
  # Différence de potentiel
  U = abs(V)
  
  # Énergie éclair typique
  I = 40000  # A
  dt = 0.0002  # s
  Q_eclair = I * dt
  E_eclair = Q_eclair * U
  E_eclair_GJ = E_eclair / 1e9
  
  # Seuil de claquage
  seuil = 3e6  # V/m = 3000 kV/m
  pct_seuil = 100 * E / seuil
  
  # Évaluation risque
  if E_kV < 50:
      risque = "FAIBLE"
  elif E_kV < 100:
      risque = "MODÉRÉ"
  elif E_kV < 200:
      risque = "ÉLEVÉ"
  else:
      risque = "CRITIQUE"
  
  return {
      'r': r,
      'E': E,
      'E_kV': E_kV,
      'V_MV': V_MV,
      'U': U,
      'E_eclair_GJ': E_eclair_GJ,
      'pct_seuil': pct_seuil,
      'risque': risque
  }

# Interface print(“=== Analyse Orage-Voilier ===”) print(“Dame Blanche (Nantucket Clipper)”) print(“”)

Q_nuage = float(input(“Charge nuage (C, ex: -60) : ”)) h_nuage = float(input(“Altitude nuage (m, ex: 2000) : ”)) d_horiz = float(input(“Distance horiz (m, ex: 800) : ”))

print(“”) print(“Calcul en cours…”) print(“”)

resultats = analyse_orage(Q_nuage, h_nuage, d_horiz)

# Affichage détaillé print(“=“*40) print(“RÉSULTATS DE L'ANALYSE”) print(”=“*40) print(f”Distance nuage-mât : {resultats['r']:.0f} m”) print(“”) print(f“Champ électrique : {resultats['E_kV']:.1f} kV/m”) print(f“Potentiel mât : {resultats['V_MV']:.1f} MV”) print(f“Différence de potentiel : {resultats['U']/1e6:.1f} MV”) print(“”) print(f“Énergie éclair : {resultats['E_eclair_GJ']:.2f} GJ”) print(f“Seuil de claquage : {resultats['pct_seuil']:.1f} %”) print(“”) print(f“NIVEAU DE RISQUE : {resultats['risque']}”) print(“=“*40)

# Recommandations print(””) print(“MESURES DE SÉCURITÉ :”) if resultats['risque'] == “FAIBLE”: 

  print("- Surveillance météo standard")
  print("- Parafoudres vérifiés")

elif resultats['risque'] == “MODÉRÉ”: 

  print("- Vigilance accrue")
  print("- Débrancher équipements non essentiels")
  print("- Équipage prêt à descendre")

elif resultats['risque'] == “ÉLEVÉ”: 

  print("- DANGER : Équipage dans cabine")
  print("- Tout débranché sauf VHF")
  print("- Ne pas toucher éléments métalliques")

else: # CRITIQUE 

  print("- DANGER IMMÉDIAT")
  print("- Équipage couché cabine")
  print("- Éloignement mât >2m")
  print("- Chaussures isolantes")

```

### Exemple d'utilisation

```

Analyse Orage-Voilier

Dame Blanche (Nantucket Clipper)

Charge nuage (C, ex: -60) : -80 Altitude nuage (m, ex: 2000) : 1500 Distance horiz (m, ex: 800) : 800

Calcul en cours…

RÉSULTATS DE L'ANALYSE

Distance nuage-mât : 1690 m

Champ électrique : 252.3 kV/m Potentiel mât : -426.4 MV Différence de potentiel : 426.4 MV

Énergie éclair : 3.41 GJ Seuil de claquage : 8.4 %

NIVEAU DE RISQUE : ÉLEVÉ

MESURES DE SÉCURITÉ : - DANGER : Équipage dans cabine - Tout débranché sauf VHF - Ne pas toucher éléments métalliques ```

—

## Programme 5 : Graphiques E et V vs distance

Fichier : `graphiques_E_V.py`

### Code complet (nécessite matplotlib sur ordinateur)

```python “”“ Programme 5 : Graphiques E® et V® Note : Pour NumWorks, adapter sans matplotlib ”“”

# Version NumWorks (sans graphique, affichage tableau) def tableau_E_V(Q, r_min, r_max, n_points): 

  """
  Génère un tableau E(r) et V(r).
  """
  k = 8.99e9
  
  print("r (m) | E (kV/m) | V (kV)")
  print("-" * 30)
  
  for i in range(n_points):
      r = r_min + i * (r_max - r_min) / (n_points - 1)
      E = k * abs(Q) / r**2
      V = k * Q / r
      print(f"{r:.2f} | {E/1000:.2f} | {V/1000:.2f}")

# Interface Q = float(input(“Charge Q (µC) : ”)) * 1e-6 r_min = float(input(“Distance min (m) : ”)) r_max = float(input(“Distance max (m) : ”)) n_points = int(input(“Nombre de points : ”))

tableau_E_V(Q, r_min, r_max, n_points) ```

—

## Programme 6 : Simulation trajectoire particule chargée

Fichier : `trajectoire.py`

### Code simplifié

```python “”“ Programme 6 : Trajectoire d'une particule chargée dans un champ uniforme ”“”

def trajectoire(q, m, E, v0x, v0y, t_max, n_steps): 

  """
  Simule la trajectoire d'une particule chargée.
  
  Paramètres:
      q : charge (C)
      m : masse (kg)
      E : champ électrique (V/m, selon y)
      v0x, v0y : vitesses initiales (m/s)
      t_max : temps total (s)
      n_steps : nombre de pas
  
  Retourne:
      listes (t, x, y, vx, vy)
  """
  dt = t_max / n_steps
  
  # Accélération
  ay = q * E / m
  ax = 0
  
  # Listes
  t_list = []
  x_list = []
  y_list = []
  
  # Conditions initiales
  t, x, y = 0, 0, 0
  vx, vy = v0x, v0y
  
  # Intégration (Euler)
  for i in range(n_steps):
      t_list.append(t)
      x_list.append(x)
      y_list.append(y)
      
      # Mise à jour
      vx += ax * dt
      vy += ay * dt
      x += vx * dt
      y += vy * dt
      t += dt
  
  return t_list, x_list, y_list

# Exemple : électron dans champ 1000 V/m q = -1.6e-19 # C m = 9.1e-31 # kg E = 1000 # V/m v0x = 1e6 # m/s v0y = 0 # m/s t_max = 1e-8 # s n_steps = 100

t, x, y = trajectoire(q, m, E, v0x, v0y, t_max, n_steps)

print(“Trajectoire calculée”) print(f“Position finale : x={x[-1]:.2e} m, y={y[-1]:.2e} m”) print(“(Graphique nécessite matplotlib sur ordinateur)”) ```

—

## DOCUMENT 8 : DOCUMENTATION FRAMAGIT

### Organisation du dépôt

``` dame-blanche-physique/ ├── README.md ├── LICENSE (CC-BY-SA 4.0) ├── module4-electricite-statique/ │ ├── doc1-notes-cours.tex │ ├── doc2-fiches-methodes.tex │ ├── doc3-grilles-evaluation.tex │ ├── doc4-guide-enseignant.tex │ ├── doc5-activites-expeyes.tex │ ├── geogebra/ │ │ ├── champ_charge_unique.ggb │ │ ├── superposition_deux_charges.ggb │ │ ├── orage_voilier.ggb │ │ └── lignes_champ_equipotentielles.ggb │ └── python/ │ ├── coulomb.py │ ├── champ.py │ ├── superposition.py │ ├── orage_voilier.py │ ├── graphiques_E_V.py │ └── trajectoire.py └── modules-suivants/ 

  ├── module5-circuits-continu/
  ├── module6-electromagnetisme/
  └── module7-circuits-alternatif/

```

### README.md du projet

```markdown # Dame Blanche - Physique Maritime ## Projet pédagogique d'apprentissage supervisé autonome

Auteur : Nicolas Pettiaux (Athénée Royal de Ganshoren, ASBL EduCode) Licence : CC-BY-SA 4.0 Contact : nicolas.pettiaux@educode.org

### Description

Modules de physique utilisant le voilier Nantucket Clipper “Dame Blanche” (1972) comme contexte authentique d'apprentissage. Approche d'apprentissage supervisé autonome avec quatre ressources : cours + tuteurs IA + validation enseignant + outils numériques.

### Module 4 : Électricité statique

- 8 documents pédagogiques complets (300+ pages) - Simulations GeoGebra interactives - Programmes Python pour NumWorks - Protocoles expérimentaux ExpEYES - Aligné avec UAA 8-9 du programme belge

### Utilisation

1. Télécharger les documents LaTeX (.tex) ou PDF compilés 2. Ouvrir les simulations GeoGebra (.ggb) 3. Charger les programmes Python sur calculatrices NumWorks 4. Adapter selon votre contexte pédagogique

### Contribution

Améliorations bienvenues ! Merge requests sur Framagit. Partagez vos adaptations sous même licence (CC-BY-SA 4.0).

### EducaLibre 2026

Conférence européenne sur le FLOSS en éducation 4-6 juillet 2026, ULB Bruxelles Ateliers Dame Blanche prévus

—

© 2025 Nicolas Pettiaux - CC-BY-SA 4.0 ```

—

FIN DES DOCUMENTS 6, 7 et 8

Tous les fichiers sources sont disponibles sur : https://framagit.org/dame-blanche-physique

Licence CC-BY-SA 4.0 - Partagez, modifiez, redistribuez librement !

</markdown>

1)
h_nuage - h_mat)^2 + d_horiz^2) # Champ électrique (en V/m puis converti en kV/m) E = k * abs(Q_nuage) / r^2 E_kV = E / 1000 # Potentiel (en V puis converti en MV) V = k * Q_nuage / r V_MV = V / 10^6 # Énergie éclair I = 40000 # A dt = 0.0002 # s Q_eclair = I * dt U = abs(V) E_eclair = Q_eclair * U E_eclair_GJ = E_eclair / 10^9 # Pourcentage seuil seuil = 3000 # kV/m pct_seuil = 100 * E_kV / seuil # Couleur selon risque couleur = If[E_kV < 50, “Vert”, If[E_kV < 100, “Orange”, “Rouge”]] # Affichage graphique # [Dessins voilier, nuage, ligne de distance, etc.] ``` ### Activités suggérées 1. Scénario standard (10 min)
  1. Q = -60 C, h = 2000 m, d = 0 m (nuage au-dessus)
  2. Noter E, V, % seuil
  3. Évaluer le risque : faible/modéré/élevé ?
2. Influence de la distance horizontale (15 min)
  1. Fixer Q = -50 C, h = 1500 m
  2. Varier d de 0 à 2000 m par pas de 200 m
  3. Observer comment E diminue quand le nuage s'éloigne
  4. Tracer E vs d
3. Recherche du seuil critique (10 min)
  1. Fixer h = 1800 m, d = 500 m
  2. Diminuer progressivement |Q| depuis -100 C
  3. Trouver la charge minimale pour E > 100 kV/m (risque élevé)
4. Comparaison avec/sans effet de pointe (5 min)
  1. Le champ calculé est le champ moyen
  2. Au sommet du mât (pointe), multiplier par facteur 10-100
  3. Si E = 30 kV/m moyen → Epointe ≈ 300-3000 kV/m → danger !
— ## Simulation 4 : Lignes de champ et surfaces équipotentielles Fichier : `lignes_champ_equipotentielles.ggb` ### Objectifs pédagogiques - Visualiser simultanément lignes de champ et surfaces équipotentielles - Comprendre leur orthogonalité - Analogie pente/altitude ### Éléments de l'interface Configuration : 2 ou 3 charges positionnables Affichage : - Lignes de champ (en rouge) - Surfaces équipotentielles (en bleu) - Points d'intersection (angles droits) Curseur : - `nb_lignes` : Nombre de lignes/surfaces affichées ### Activités suggérées 1. Observation qualitative (5 min)
  1. Vérifier que lignes et surfaces sont perpendiculaires partout
2. Analogie montagne (10 min)
  1. Surfaces équipotentielles = courbes de niveau
  2. Lignes de champ = lignes de plus grande pente
  3. Déplacement le long d'une équipotentielle : W = 0
— # DOCUMENT 7 : PROGRAMMES PYTHON NUMWORKS ## Introduction Ces programmes Python sont conçus pour les calculatrices NumWorks. Ils peuvent aussi fonctionner sur ordinateur avec Python standard (avec adaptations mineures pour les graphiques). Chargement sur NumWorks : 1. Connecter la calculatrice via USB 2. Aller sur https://my.numworks.com/python 3. Créer un nouveau script 4. Copier-coller le code 5. Télécharger vers la calculatrice Utilisation : - Exécuter le script - Saisir les données demandées - Observer les résultats affichés ou les graphiques — ## Programme 1 : Calcul force de Coulomb Fichier : `coulomb.py` ### Code complet ```python “”“ Dame Blanche - Module 4 : Électricité statique Programme 1 : Calcul de la force de Coulomb Licence : CC-BY-SA 4.0 Auteur : Nicolas Pettiaux ”“” def coulomb(q1, q2, r):
  """
  Calcule la force de Coulomb entre deux charges ponctuelles.
  
  Paramètres:
      q1, q2 : charges (C)
      r : distance (m)
  
  Retourne:
      F : force (N)
  """
  k = 8.99e9  # N·m²/C²
  F = k * abs(q1 * q2) / r**2
  return F
def sens_force(q1, q2):
  """
  Détermine si la force est attractive ou répulsive.
  
  Retourne:
      "Attraction" ou "Répulsion"
  """
  if q1 * q2 > 0:
      return "Répulsion"
  else:
      return "Attraction"
# Interface utilisateur print(“=== Force de Coulomb ===”) print(“”) q1 = float(input(“Charge q1 (en µC) : ”
/var/www/alternc/e/educode/www/educode.be/dokuwiki/data/pages/cours_de_physique_sur_dame_blanche.txt · Dernière modification : de Nicolas Pettiaux