physique-chimie

2 TSI-2

Capacités numériques en

Python
physique-chimie : utilisation de
python

Table des matières

1 Écriture de code et exécution 2

1.1 Les variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2 Le choix du nom des variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.3 Les instructions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.4 Les blocs d’instructions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.5 Les valeurs et types de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

2 Les structures de contrôle – Instructions 3

2.1 Conditions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.2 Les opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.3 Les structures de contrôle – Itérations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.4 La gestion des caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.5 Les chaı̂nes de caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
ELKIHEL

3 Les listes 6
3.1 Les tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
3.2 Les listes modifiables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
3.3 Utilisation spéciale des listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
3.4 Des listes comme tableau à 2 dimensions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

4 Système linéaire 8

5 Les modules et l’espace de nom 9

6 Les fonctions : définition-arguments 9

6.1 Application-1 : détermination de l’état d’équilibre d’un système chimique . . . . . . . . . . . . . . . . . 10
6.2 Application-2 : diagramme de distribution d’un diacide H2A . . . . . . . . . . . . . . . . . . . . . . . . 11

7 Résolution numérique d’équations différentielles 12

7.1 Position du problème . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
7.2 La méthode d’Euler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
7.3 Principe de la méthode d’Euler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

8 Mise en oeuvre de la méthode d’Euler 14

8.1 Équations du premier ordre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
8.2 Équations du deuxième ordre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
CPGE-MOHAMMEDIA

8.3 Utilisation de la fonction odeint du module scipy.integrate . . . . . . . . . . . . . . . . . . . . . . . . . 19

8.4 Oscillateur amorti-animation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
8.5 Oscillateur de Wien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
8.6 Frottement fluide . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
8.7 Mouvement à force centrale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

9 Filtrage 28

10 Ondes 30

11 Interférences lumineuses 31

1
 physique-chimie
1 Écriture de code et exécution
2 TSI-2

L’extension par défaut d’une source Python est ” .py ”. Pour exécuter une source Python (la compilation et l’exécution

Python
sont simultanées), on appelle l’interprète Python de l’extérieur du programme :
1 - en tapant dans l’invité de commande python suivi de l’emplacement du fichier source.py ;
2 - en utilisant un programme de compilation du code python comme (sublime Text , pyscript , pyzo ...).
Dans les exemples de ce document on va utiliser IDLE de python, Thonny idle ou sublime text3.
ELKIHEL

1.1 Les variables

Une variable doit exister avant d’être référencée dans le programme. Il faut l’instancier avant de s’en servir, si non il y
aura une erreur.
print(a) provoque une erreur car a n’existe pas.

Les variables a et b font références à la même chaı̂ne de caractères. Une variable ne référençant rien, a pour valeur
CPGE-MOHAMMEDIA

None.
Il n’existe pas de constante en Python (pour signifier une constante, on utilise un nom tout en majuscule).
1.2 Le choix du nom des variables
Python est sensible à la casse, il fait la différence entre minuscules et majuscules.
Les noms des variables doivent être différents des mots réservés du langage. Les mots réservés :
and , assert , break , class , continue , def , del , elif , else , except , exec finally , for , from , global ,
if import , in , is , lambda , not , or , pass , print , raise , return , try , while
1.3 Les instructions
Les commentaires vont du caractère # jusqu’à la fin de la ligne.
Chaque instruction s’écrit sur un ligne, il n’y a pas de séparateur d’instruction. Si une ligne est trop grande, le caractère
permet de passer à la ligne suivante.

2
 physique-chimie
1.4 Les blocs d’instructions
2 TSI-2

Les blocs d’instruction sont matérialisés par des indentations.

Python
Le caractère ”:” sert à introduire les blocs.
La syntaxe est allégée, facile à lire et agréable.
1.5 Les valeurs et types de base
Il existe des valeurs prédéfinies :
True : valeur booléenne vraie.
ELKIHEL

False : valeur booléenne vide.

None : objet vide retourné par certaines méthodes/fonctions.
Python interprète tout ce qui n’est pas faux à vrai.
Est considéré comme faux :
* 0 ou 0.0 la valeur 0.
’ ’ chaı̂ne vide.
” ” chaı̂ne vide.
( ) liste non modifiable ou tuple vide.
[ ] liste vide.
{} dictionnaire vide.
2 Les structures de contrôle – Instructions
2.1 Conditions
Les séquences d’instructions
Une ligne contient une seule instruction. Mais il est possible de mettre plusieurs instructions sur une même ligne en les
séparant par des ; (syntaxe déconseillée).

Produit
1 >>> a =1; b =2; c = a * b
2 >>> print ( c )
3 2
4 >>>
CPGE-MOHAMMEDIA

Les conditions
Faire toujours attention aux tabulations !
Lorsqu’une seule instruction compose la condition, il est possible de l’écrire en une seule ligne :

Test if
1 >>> a =5
2 >>> if a >1 : b =3* a ; print ( b )
3
4 15
5 >>>

3
 physique-chimie
2.2 Les opérateurs
2 TSI-2

Logique or OU logique ; and ET logique ; not négation logique

Python
Comparaison
<,>,<=,>=,==,!= inférieur, sup., inférieur ou égale, sup. ou égale, égale, différent.
is , is not comparaison d’identité (même objet en mémoire).

Test is
1 >>> c1 = ’ toto ’
2 >>> c2 = ’ toto ’
3 >>> print ( c1 is c2 , c1 == c2 ) # teste l ’ identit é et teste le contenu
4 True True
5 >>> print ( c1 is c2 , c1 != c2 ) # teste l ’ identit é et teste le contenu
6 True False
7 >>>

Arithmétique
+,−,∗,/,//,% addition, soustraction, multiplication, division, division entière, modulo +=,−=,... opération + affectation
de la valeur modifiée.
2.3 Les structures de contrôle – Itérations
La boucle while dépend d’une condition.
ELKIHEL

boucle while
1 >>> x =10
2 >>> while x <15:
3 x +=1 # x varie de raison = 1
4 print ( ’x = ’ , x )
5 else :
6 print ( x , ’ Stop x n est plus < 15 ’)
7
8
9 x = 11
10 x = 12
11 x = 13
12 x = 14
13 x = 15
14 15 Stop x n est plus < 15

Les ruptures de contrôle :

continue : continue directement à la prochaine itération de la boucle.
break : sort de la boucle courante (la plus imbriquée).
pass : instruction vide (ne rien faire).
Le else de la structure de contrôle n’est exécuté que si la boucle n’a pas été interrompue par un break.
Boucle infinie
CPGE-MOHAMMEDIA

Il est souvent pratique d’utiliser une boucle while infinie (dont la condition est toujours vraie), et d’utiliser les ruptures
de séquences.

boucle while infini

1 >>> x =1
2 >>> while 1:
3 x +=2
4 if x <20:
5 print ( ’x = ’ , x )
6 else :
7 print ( ’x = ’ , x , ’x n est plus <20 ’)
8 break # pour sortir de la boucle infine

4
 physique-chimie
9 # pass pour rester dans la boucle infine
2 TSI-2

10

Python
11
12 x= 3
13 x= 5
14 x= 7
15 x= 9
16 x = 11
17 x = 13
18 x = 15
19 x = 17
20 x = 19
21 x = 21 x n est plus <20
22 >>>

2.4 La gestion des caractères

Il n’existe pas de type caractère mais seulement des chaı̂nes contenant un caractère unique. Une chaı̂ne est délimitée par
des ’ ou des ” ce qui permet d’en utiliser dans une chaı̂ne :
+ le caractere = ’c’ ;
+ a = ”une chaine avec des ’quotes’” , ou ’une chaine avec des ”doubles quotes”’.

chaine-caractère
1 >>> a = " cours d ’ initiation au proramaation en python "
ELKIHEL

2 >>> print ( len ( a ))

3 46
4 >>> b = " le programme ’
5 SyntaxError : EOL while scanning string literal
6 >>> b = ’ le programme ’
7 >>> print ( len ( b ))
8 12
9 >>> c = ’ leprogramme ’ # l ’ espace est un caract è re
10 >>> print ( len ( c ))
11 11
12 >>>

La fonction len() permet d’obtenir la longueur d’une chaı̂ne. Il est possible d’écrire une chaı̂ne contenant plusieurs lignes
sans utiliser le caractère / n, en l’entourant de 3 guillemets :
texte = ””” premiere ligne
deuxieme ligne”””
Pour pouvoir utiliser le caractère d’échappement dans une chaı̂ne il faut la faire précéder de r (pour raw) :
En particulier, ce sera important lors de l’entrée d’expressions régulières.
Concaténation
Il est possible de concaténer deux chaines de caractères avec l’opérateur + :
a = ”ma chaine” + ” complete”
print(a)
2.5 Lesretournera ma chaine complete
chaı̂nes de caractères
CPGE-MOHAMMEDIA

Il est possible d’insérer le contenu d’une variable dans une chaı̂ne de caractères à l’aide du %.

formatage

1 >>> a =10.0
2 >>> print ( a )
3 10.0
4 >>> b = ’ La valeur est % d ’% a # % d un entier
5 >>> print ( b )
6 La valeur est 10
7 >>> b = ’ La valeur est %.2 f ’% a # % f valeur flottante ,%.2 f indique 2
8 >>> print ( b ) # chiffres apr è s la virgule
9 La valeur est 10.00

5
 physique-chimie
10 >>> b = ’ La valeur est % x ’% a
2 TSI-2

11 Traceback ( most recent call last ):

Python
12 File " < pyshell #14 > " , line 1 , in < module >
13 b = ’ La valeur est % x ’% a
14 TypeError : % x format : an integer is required , not float
15 >>> c =20
16 >>> b = ’ La valeur est % x ’% c # % x entier sous forme hexad é cimal
17 >>> print ( b )
18 La valeur est 14
19 >>> b = ’ La valeur est % s ’% a % s cha ^ ı ne de caract è res
20 >>> c = str ( b ) # on r é cup è re le r é sultat de la commande str ()
21 >>> print ( c )
22 La valeur est 10.0
23 >>>

Les chaı̂nes sont nt des objets → un objet offre des méthodes. Les chaı̂nes proposent différentes méthodes :

objet

1 a = ’ ligne1 \ nligne2 \ nligne3 ’# chaine de caract è re de 3 lignes :\ n = retour à

la ligne
2 b = a . splitlines () # retourne une liste des 3 lignes
3 print ( b )
ELKIHEL

4 [ ’ ligne1 ’ , ’ ligne2 ’ , ’ ligne3 ’] # b = a . splitlines ()

5 a = ’ ligne1 ligne2 ligne3 ’ # pas de retour à la ligne \ n !
6 b = a . splitlines ()
7 print ( b )
8 [ ’ ligne1 ligne2 ligne3 ’]
9 c = a . rstrip ( ’\ n ’) # suppression des retours à la ligne
10 print ( c )

3 Les listes
3.1 Les tuples
Ces listes peuvent contenir n’importe quel type de données.
Il existe deux types de listes :
+ celles qui ne peuvent être modifiées, appelées tuples. Elles sont notées sous forme d’éléments entre parenthèses séparés
par des virgules ;
+ les autres, qui sont modifiables, appelées simplement liste !

les tuples

1 >>> a =( ’ un ’ , 2 , ’ trois ’)
2 >>> print ( a )
3 ( ’ un ’ , 2 , ’ trois ’)
4 >>> print ( len ( a )) # La fonction len () renvoie le nombre d ’é l é ments de la liste
CPGE-MOHAMMEDIA

5 3
6 >>> print ( a [0]) # l ’ indice de l ’é l é ment ’ un ’ est é gale à 0
7 un
8 >>> print ( a [ -1]) # indice -1 renvoie le dernier é l é ment du tuple
9 trois
10 >>> b =(4 , ’ cinq ’ , ’ dix ’ ,20)
11 >>> c = a + b # somme de deux tuples
12 >>> print ( c )
13 ( ’ un ’ , 2 , ’ trois ’ , 4 , ’ cinq ’ , ’ dix ’ , 20)
14 >>> print ( c [2:4]) # extraire un tuple d ’ un tuple existant
15 ( ’ trois ’ , 4)
16 >>> print ( c [2:]) # renvoie le tuple dont l ’ indice est > ou = à 2
17 ( ’ trois ’ , 4 , ’ cinq ’ , ’ dix ’ , 20)
18 >>>

6
 physique-chimie
3.2 Les listes modifiables
2 TSI-2

Elles sont notées sous forme d’éléments entre crochets séparés par des virgules.

Python
Elles correspondent à des objets contrairement aux tuples.

manipulations de listes

1 >>> L =[3 , ’ physique ’ , ’ chimie ’ ,20]

2 >>> print ( L [1])
3 physique
4 >>> L . append ( ’ python ’)
5 >>> print ( L ) # ajouter un é l é ment à la liste ( nouvelle liste L ’)
6 [3 , ’ physique ’ , ’ chimie ’ , 20 , ’ python ’]
7 >>> L . pop (2)
8 ’ chimie ’
9 >>> print ( L ) # enl è ve l ’é l é ment d ’ indice 2 de la liste ( nouvelle liste L ")
10 [3 , ’ physique ’ , 20 , ’ python ’]
11 >>> L . index (3) # retourne l ’ indice de l ’é l é ment 3
12 0
13 >>> a =[1 ,5 ,3 ,20 ,10 , ’ deux ’]
14 >>> a . sort ()
15 Traceback ( most recent call last ):
16 File " < pyshell #12 > " , line 1 , in < module >
17 a . sort ()
18 TypeError : ’ < ’ not supported between instances of ’ str ’ and ’ int ’
ELKIHEL

19 >>> a . pop (5) # on enl è ve le string ( str ) ’ deux ’

20 ’ deux ’
21 >>> a . sort () # trier des chiffres ( des int )
22 >>> print ( a )
23 [1 , 3 , 5 , 10 , 20]
24 >>> b =[4 , ’ un ’]
25 >>> a . extend ( b ) # ajouter les é l é ments de b à a
26 >>> print ( a )
27 [1 , 3 , 5 , 10 , 20 , 4 , ’ un ’]
28 >>> a . pop (6)
29 ’ un ’
30 >>> a . reverse ()
31 >>> print ( a )
32 [4 , 20 , 10 , 5 , 3 , 1]
33 >>> a . sort ()
34 >>> print ( a )
35 [1 , 3 , 4 , 5 , 10 , 20]
36 >>> c =[1 , 3 , 5 , 10 , 20 , 4 , ’ un ’]
37 >>> c . reverse ()
38 >>> print ( c )
39 [ ’ un ’ , 4 , 20 , 10 , 5 , 3 , 1]
40 >>>

3.3 Utilisation spéciale des listes

Affectation multiples-appartenance
CPGE-MOHAMMEDIA

Test-listes
1 >>> a ,b , c = 10 ,20 ,30
2 >>> print ( a )
3 10
4 >>> print (b , c )
5 20 30
6 >>> c =[2 , ’a ’ ,5 ,20]
7 >>> 4 in c # appartenance à une liste
8 False
9 >>> ’a ’ in c
10 True

7
 physique-chimie
11 >>> 2 in c
2 TSI-2

12 True

Python
13 >>>

3.4 Des listes comme tableau à 2 dimensions

Il n’existe pas de tableau à deux dimensions en Python comme dans d’autres langages de programmation.
+ Un tableau à une dimension correspond à une liste.
+ Un tableau à deux dimensions correspond à une liste de listes.
Création et utilisation du tableau à deux dimensions
tableau-1
1 >>> nb_lignes =5
2 >>> nb_colonnes =3
3 >>> tableau_2D = [] # une liste vide qui sera transform é en tableau
4 >>> for i in range ( nb_lignes ):
5 tableau_2D . append ([]) # cr é ations de 5 lignes vides ( des listes vides )
6 for j in range ( nb_colonnes ):
7 tableau_2D [ i ]. append ( j ) # remplissage des colonnes de la ligne i
8
9 >>> print ( tableau_2D ) # on affiche le tableau
10 [[0 , 1 , 2] , [0 , 1 , 2] , [0 , 1 , 2] , [0 , 1 , 2] , [0 , 1 , 2]]
11 >>>
ELKIHEL

tableau-2
1 >>> nb_lignes =5
2 >>> nb_colonnes =3
3 >>> tableau_2D = []
4 >>> L =[1 ,3 ,5 ,10 ,8 ,20] # on va remplir les lignes par les valeurs de L
5 >>> import random # choix al é atoire d ’ une valeur de L ( fonction random . choice )
6 >>> for i in range ( nb_lignes ):
7 tableau_2D . append ([]) # cr é ations des lignes vides ( des listes vides )
8 for j in range ( nb_colonnes ):
9 tableau_2D [ i ]. append ( random . choice ( L ))
10 # on ajoute une valeur al é atoire de L à
11 # la colonne j de la ligne i
12
13 >>> print ( tableau_2D ) # tableau de 5 lignes et 3 colonnes
14 [[8 , 3 , 1] , [10 , 20 , 20] , [5 , 10 , 3] , [1 , 8 , 3] , [5 , 3 , 8]]
15 >>> print ( tableau_2D [2]) # on affiche la 3 è me ligne ( ligne d ’ indice 2)
16 [5 , 10 , 3]
17 >>> print ( tableau_2D [2][1]) # on affiche la 2 è me colonne ( indice 1 )
18 10 # de la 3 è me ligne ( ligne d ’ indice 2)
19 >>>
CPGE-MOHAMMEDIA

4 Système linéaire
     
 3x−2y+z =1 3 −2 1 x 1
On considère le système d’équations : x+3y−z =2 et sous forme matricielle 1 3 −1  y  =  2 
x−y =−1 1 −1 0 z −1

Pour résoudre ce système on utilise le module numpy

8
 matrice-système

physique-chimie
2 TSI-2

1 >>> import numpy as np

Python
2 >>> a = np . array ([[3 , -2 ,1] ,[1 ,3 , -1] ,[1 , -1 ,0]]) # matrice = tableau 3 x3
3 >>> b = np . array ([15 ,30 , -15]) # vecteur image
4 >>> X = np . linalg . solve (a , b ) # é quation retourne la solution X
5 >>> print ( X )
6 [ 6. 21. 39.]
7 >>> [x ,y , z ]= np . linalg . solve (a , b )
8 >>> print ([ x ,y , z ])
9 [6.0 , 21.0 , 39.0]
10 >>> from sympy import symbols # deuxi è me m é thode
11 >>> from sympy . solvers import solve # on utilise symbols et solve
12 >>> x ,y , z = symbols ( ’x ,y , z ’)
13 >>> eqt_1 =3* x -2* y + z -15 # =0
14 >>> eqt_2 = x +3* y - z -30 # =0
15 >>> eqt_3 = x - y +15 # =0
16 >>> Y = solve ([ eqt_1 , eqt_2 , eqt_3 ] ,(x ,y , z ))
17 >>> print ( ’x = ’ , Y . get ( x ) , ’y = ’ , Y . get ( y ) , ’z = ’ , Y . get ( z ))
18 x = 6 y = 21 z = 39
19 >>>

5 Les modules et l’espace de nom

Un module regroupe un ensemble cohérent de fonctions, classes objets, variables globales (pour définir par exemple des
ELKIHEL

constantes).
Chaque module est nommé. Ce nom définit un espace de nom.
En effet, pour éviter des collisions dans le choix des noms utilisés dans un module avec ceux des autres modules, on utilise
un accès préfixé par le nom du module : nom-module.element défini dans le module
Il existe de nombreux modules pour Python capables de lui donner des possibilités très étendues.
Accès à un module dans un autre se fait grâce à la commande import.
6 Les fonctions : définition-arguments
La définition d’une fonction se fait à l’aide de def :
+ def ma-fonction() :
+ instructions.
Les paramètres de la fonction peuvent être nommés et recevoir des valeurs par défaut. Ils peuvent ainsi être donnés dans
le désordre et/ou pas en totalité (très utile pour les objets d’interface comportant de nombreux paramètres dont seulement
certains sont à changer par rapport à leur valeur par défaut).

fonction
1 >>> def carre ( x ) :
2 return x **2 # faonction qui retourne le carr é d ’ un nombre
3
4 >>> y = carre (2)
5 >>> print ( y )
6 4
7 >>> def fct_2 (x , y ) :
CPGE-MOHAMMEDIA

8 return x ,2* y # fonction 2 variables retourne un tuple

9
10 >>> l = fct_2 (3 ,5)
11 >>> print ( l )
12 (3 , 10)
13 >>>

fonction-courbe
1 import numpy as np # on va d é finir une fonction sinus
2 def f_sin ( x ) :
3 return 2* np . sin ( x )

9
 physique-chimie
4
2 TSI-2

5 x = np . linspace (0 ,10 ,100) # l ’ axe des x de 100 points de 0 à 10

Python
6 import matplotlib . pylab as plt # on va tracer la courbe f_sin ( x )
7 plt . plot (x , f_sin ( x ) , ’r -. ’) # plt . plot = tracer
8 plt . grid () # on affiche la grille
9 plt . savefig ( ’ pdf / sin . pdf ’)
10 plt . show ()

2.0
1.5
1.0
0.5
0.0
0.5
1.0
1.5
ELKIHEL

2.0
0 2 4 6 8 10

6.1 Application-1 : détermination de l’état d’équilibre d’un système chimique

Un mélange d’acide acétique CH3COOH, d’acide benzoique C6H5COOH, d’ions acétate CH3COO− et d’ions benzoate
C6H5COO− est susceptible d’évoluer suivant la réaction d’équation :
− −
CH3COO(aq) +C6H5COOH(aq) →CH3COOH(aq) +C6H5COO(aq)
Le tableau d’avancement est :
− −
CH3COO(aq) C6H5COOH(aq) → CH3COOH(aq) C6H5COO(aq)
c c c c
c-x c-x c+x c+x
La constante d’équilibre à 25oC est K =3,20.
On mélange quatre solutions de même volume Vo =25,0mL d’acétate de sodium, de benzoate de sodium, d’acide benzoique
et d’acide acétique chacune à Co =2.10−2mol.L−1 .
Déterminer l’avancement volumique de la réaction à l’équilibre.
(c+x)2 Co.Vo
La constante d’équilibre du système chimique est : K = 2
, avec c=
(c−x) 4.Vo

Etat d’équilibre d’un système chimique

CPGE-MOHAMMEDIA

1 from sympy . solvers import solve

2 from sympy import *
3 Vo , Co , K =0.025 , 0.02 ,3.2
4 C = Co * Vo /(4* Vo ) # dilution d ’ un facteur de 4
5 print ( ’ la concentaration de la solution dilu é e est C = ’ , C )
6 x = Symbol ( ’x ’)
7 def f ( x ) :
8 return K *( C - x )**2 - ( C + x )**2
9 X = solve ( f ( x ) , x ) # avec la solution x < C
10 print ( X ) # pour avoir une id é e sur les chiffres significatifs
11 x1 = float ( X [0])
12 x2 = float ( X [1])

10
 physique-chimie
13 print ( ’ les solutions sont : x1 = ’ , round ( x1 ,3) , ’ et x2 = ’ , round ( x2 ,3))
2 TSI-2

14 print ( " [ CH3COO -( aq )]= C1 = " , round ( x1 ,3))

Python
6.2 Application-2 : diagramme de distribution d’un diacide H2A

Acide carbonique
L’acide carbonique se forme en particulier
  dans l’eau par solvatation du dioxyde de carbone :
CO2(aq) +H2O(l)
H2CO3(aq)
 
avec une constante d’équilibre d’hydratation valant Kh =[H2CO3]/[CO2]≈1,70.10−3 à 25oC.
En solution aqueuse, l’acide
( carbonique H2CO3 est un diacide, c’est-à-dire qu’il peut se dissocier deux fois en libérant
+ −
H2O(l) +H2CO3(aq)
H3O(aq) +HCO3(aq) :pKa1 =6,37
chaque fois un proton : − + 2−
H2O(l) +HCO3(aq)
H3O +CO3(aq) :pKa2 =10,32
Quand l’acide carbonique est combiné avec un cation, des sels nommés bicarbonates et carbonates peuvent se former.
Par exemple, combiné avec de la chaux (hydroxyde de calcium Ca(OH)2), il constitue du carbonate de calcium
(constituant principal du calcaire, de la craie).
On pose C =c,[H2A]=x,[HA−]=y et [A2−]=c−x−y ,[H]=h=10−pH .
1- Exprimer les constantes d’équilibre ka1 et ka2, en déduire un système à deux équations fonction de ka1,ka2,x,y,h
et c.
2 - En utilisant python, résoudre ce système d’équations.
x y
3 - Exprimer les coefficients de dissociation de l’acide carbonique αx = ,αy = et αCO2− .
c c 3
4 - Tracer les courbes représentatives des coefficients de dissociation de l’acide carbonique en fonction de pH.
ELKIHEL

Diagramme de distribution de H2CO3

1 from sympy import symbols

2 from sympy . solvers import solve
3 import numpy as np
4 """
5 L ’ acide carbonique H2CO3 est un diacide de constantes d ’ acidit é s pka1
6 =6 ,37 et pka2 =10 ,32.
7 On consid è re une solution de cet acide de concentration c . on pose , x
8 =[ AH2 ] , y =[ AH ] et
9 [ A ] = c -x - y =z , de plus h =10** - pH .
10 1 - Donner les trois é quations v é rifi é es par x ,y ,z , ka1 , ka2 , c et h .
11 2 - prposer un programme python pour resoudre le syst è me de ces é qua
12 tions .
13 3 - pour é valuer les expressions de x , y et z pour h donn é , on uilise
14 la fonction python
15 eval ( str ()) qui va lire l ’ expression est retourne sa valeur une fois
16 h donn ée , lier cette fonction
17 à trois fonction F1 ( h ) , F2 ( h ) et F3 ( h ) pour tracer les courbes x , y
18 et z en fonction de pH sachant
19 que h =10** - pH " " "
CPGE-MOHAMMEDIA

20 # 1 - les trois é quations - - - - - - - - - - - - - - - - - - - - - - - - - -

21 x ,y ,z , ka1 , ka2 ,c , h = symbols ( ’x ,y ,z , ka1 , ka2 ,c , h ’) # on d é finit les var
22 # iables comme des symbols
23 eqt_1 = ka1 *x - h * y # à partir de l ’ expression de ka1 = h . y / x = > ka1 * x - y * h =
24 #0
25 eqt_2 = ka2 *y - h * z # à partir de l ’ expression de ka2 = h . z / y = > ka2 * y - z * h
26 # =0
27 eqt_3 = x + y +z - c # à partir de la conservation de la mati è re x + y + z = c
28 # 2 - r é solution des é quations - - - - - - - - - - - - - - - - - - - -
29
30 X = solve ([ eqt_1 , eqt_2 , eqt_3 ] , (x ,y , z ))
31 # la fonction solve () retourne un dictionnaire :{ x : expression de l ’ ob
32 # jet x , y : ... de y , z : ... de z }
33 Y =( X . get ( x ) , X . get ( y ) , X . get ( z )) # Y =( x ,y , z ) = > Y [0]= x =[ AH2 ] , Y [1]= y =[

11
 physique-chimie
34 # AH ] et Y [2]= z =[ A ]
2 TSI-2

35 # 3 valeurs num é riques à partir des expressions de x , y et z et le tr

Python
36 print ( Y ) # ac é des courbes - ---- --- ---
37 # --- d é finition des fonctions F1 ( h ) , F2 ( h ) et F3 ( h )
38 def AH2 ( h ) : # cette fonction retourne la valeur du taux de dissociatio
39 # n de AH2 pour h donn é e
40 return eval ( str ( Y [0]/ c )) # on divise par c , liste du taux de dis
41 def AH ( h ) : # sociation de [ AH2 ]
42 return eval ( str ( Y [1]/ c )) # liste taux de dissociation de [ AH ]
43 def A ( h ) :
44 return eval ( str ( Y [2]/ c )) # liste taux de dissociation de [ A2 -]
45
46 c , ka1 , ka2 ,= 0.01 ,10** -6.37 , 10** -10.32
47 pH = np . linspace (0 ,14 ,100) # l ’ intervalle de pH
48 h =10** - pH # h en fonction de pH
49
50 from pylab import *
51 figure ( figsize =(6 ,5))
52 subplots_adjust ( left =0.06 , right =0.95 , top =0.95 , bottom =0.05)
53 plot ( pH , AH2 ( h ) , ’r -. ’ , label = ’ $H_2CO_3$ ’)
54 plot ( pH , AH ( h ) , ’b - ’ , label = ’ $HCO_3 ^ - $ ’)
55 plot ( pH , A ( h ) , ’g : ’ , label = ’ $CO_3 ^{2 -} $ ’)
56 legend ()
57 title ( " diagramme de distribution d ’ un diacide " )
ELKIHEL

58 grid ()
59 savefig ( " pdf / diacide . pdf " )
60 show ()

diagramme de distribution d'un diacide

1.0

0.8

0.6
H2CO3
HCO3
CO32
0.4

0.2

0.0
0 2 4 6 8 10 12 14
CPGE-MOHAMMEDIA

7 Résolution numérique d’équations différentielles

7.1 Position du problème
En général l’évolution d’un système physique est régi par une équation différentielle, l’étude de cette évolution revient à
résoudre cet équation !
Considérons l’équation différentielle suivante :
y0(t)=5y2(t)−y(t) ; y(0)=1
C’est une équation différentielle d’ordre 1, mais elle n’est pas linéaire. Nous ne savons pas la résoudre de manière exacte.
Nous allons toute fois pouvoir la résoudre numériquement.
Remarquons déjà que cette équation peut s’écrire sous la forme :
 0
y (t)=F (y(t),t)
avec F (a,b)=5a2 −a)
12
 Il existe une unique application y de classe C1 sur [t0,tf ] vérifiant le problème de Cauchy :

physique-chimie
 0
y (t)=F (y(t),t)
2 TSI-2

y(t0)=y0

Python
7.2 La méthode d’Euler
La méthode d’Euler (mathématicien et physicien suisse (1707-1783)) est une méthode de résolution d’une équation
différentielle ordinaire (EDO) de premier degré. Son principe est relativement simple et s’appuie sur des outils abordables,
car il s’agit essentiellement de dérivée.
Mais revenons d’abord à la signification d’une équation différentielle de premier ordre. Pour un physicien, une EDO indique
l’évolution d’un système physique en fonction de l’accroissement d’un paramètre, très généralement le temps.
y(t+dt)−y(t)

 y0(t)=

dt 0
 y(t+dt)=y(t)+y (t).dt

avec dt→0
7.3 Principe de la méthode d’Euler
L’idée
 principale est que ”localement la courbe de la  fonction y ressemble à sa tangente”. Ainsi si h est proche de 0, on
0
a : y(t0 +h)=y(t0)+h.y (t0)=y(t0)+h.F (y(t0),t0)
 
On peut donc approcher y(t0 +h) par la quantité y(t0)+h.F (y(t0),t0).
tf −t0
On découpe ainsi l’intervalle de temps [t0,tf ] en n segments de même longueur h= (on dit que h est le pas). On dispose
n
ainsi de n+1 temps tk =t0+kh pour k ∈0,...,n. On va alors approximer la solution  y à linstant tk par le nombre yk défini par
la relation de récurrence : yk+1 =yk +h.F (yk ,tk )⇒yk+1 −yk =h.F (yk ,tk )=y+ est le pas de la fonction y(t) en code python.
 
On initialise enfin avec la condition initiale y0 =y(t0).
ELKIHEL

Exemple : considérons la fonction f(t)=et.

courbe approchée - courbe analytique

1 # f ’( t )= exp ( t )= y = > y ( t )= exp ( t ) courbe analytique avec y (0)=1

2 # et courbe approch é e y ( t + dt ) = y ( t ) + dt * f ’( t ) = y ( t )+ dt * y ( t )
3 # on compare les deux trac é s
4 [ t0 , tf ] , n = [0 ,5] ,100 # intervalle temps , nombre de points
5 h = ( tf - t0 )/ n # la dur é e dt
6 y0 =1 # condition initiale sur f ( t ) c à d y
7 T =[ t0 ] # initiation de la liste des instants tk
8 Y =[ y0 ] # initiation de la liste des yk = f ( tk )
9 # +++++++++++++++++ on cr é e les listes T et Y ++ +++ ++++ +++ ++++ +++ +++
10 t , y , dt = t0 , y0 , h
11 for k in range ( n ): # point d ’ indice k
12 t += dt # la variation de t est dt
13 T . append ( t )
14 y = y + y * dt # y ( k )= y (k -1)+ y ’(k -1)* dt et y ’(k -1)= y (k -1)
15 Y . append ( y )
16 # +++++++++++ on trace les deux courbes Y = f ( T ) et exp ( t ) +++++++++
17 import matplotlib . pylab as plt
18 import numpy as np
19 plt . xlim (0 , tf )
20 plt . ylim (0 , max ( Y ))
CPGE-MOHAMMEDIA

21 plt . plot (T ,Y , ’r -. ’) # la courbe Y = f ( T )

22 t = np . linspace (0 ,5 , n )
23 plt . plot (t , np . exp ( t ) , ’b - ’) # la courbe exp ( t )
24 plt . savefig ( ’ fonction_exp . pdf ’)
25 plt . show ()

13
 physique-chimie
2 TSI-2

Python
120

100

80

60

40

20

0
0 1 2 3 4 5
ELKIHEL

fig-0

Code python Euler :

Par la suite on crée un code python d’une fonction qui retourne un tableau Y =[yk ] de vecteurs (listes) yk pour k ∈[0,n] avec
tn −t0
y0(tk )=F (yk ,tk ) et tk in [t0,tn] avec un pas de h= et qui sert à résoudre un système d’équations différentielles d’ordre 1.
n
Module Euler
1 import numpy as np
2 def euler (F ,y , t ) : # y =[ y1 , y2 , y3 ,.....]
3 h = ( t [1] - t [0]) # h = dt
4 n_h =100 # nombre de point dans l ’ intervalle h
5 dt = h / n_h # valeur trop petite pour une bonne approximation
6 N = len ( t )* n_h
7 Y = [] # liste de la liste des valeurs initiales
8 for k in range ( N ):
9 for i in range ( len ( y )):
10 y [ i ]= y [ i ] + dt * F (y , t )[ i ] # y ( t_k +1) = y ( t_k ) + h * y ’( t_k )
11 if k % n_h ==0 and len ( Y ) <= len ( t ) :
12 Y . append ( list ( y )) # on rajoute les valeurs d ’ ordre k > 0
13 else :
CPGE-MOHAMMEDIA

14 pass
15 return np . array ( Y ) # transforme la liste Y ( de len ( t ) listes a len ( y
16 # ) colonnes ) en un tableau ( len ( t ) lignes a len ( y ) colonnes )

tf −t0
La quantité h= est appelée le pas. Plus le pas est petit, meilleure sera l’approximation.
n
8 Mise en oeuvre de la méthode d’Euler
8.1 Équations du premier ordre
Appliquons notre fonction Euler du module Euler, en l’important depuis son module.
On va considérer que le fichier source python de notre fonction est module euler.py.

14
 Régime transitoire-modèle d’Euler-animation : dipôle RC

physique-chimie
2 TSI-2

1 from moduleEuler import euler

Python
2 # +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
3 import numpy as np
4 from pylab import *
5 # +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
6 def charge (y , t ) : # , du / dt + u / tau = E / tau
7 return -y [0]/ tau + E / tau , # retourne y ’= dy / dt avec y liste = tuple
8 def decharge (y , t ) :
9 return -y [0]/ tau ,
10 # - - - -- - - -- -- - param è tres de la simulation - - - - - - - - - - - - - - - - - - - - - - - - - - -
11 tau =1
12 E = 1
13 n =50
14 # - - - - - - - - - - - - - - - la phase de la charge - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
15 t_c = np . linspace (0 ,5* tau , n )
16 Y_c = euler ( charge ,[0] , t_c ). T
17 u_c = Y_c [0]
18 # - - - - - - - - - - - - - - - - la phase de la d é charge - - - - - - - - - - - - - - - - - - - - - - - - - - -
19 t_d = np . linspace (5* tau , 10* tau , n )
20 Y_d = euler ( decharge ,[ max ( Y_c [0])] , t_d ). T # max ( Y_c [0])= Y_d initiale
21 u_d = Y_d [0]
22 # +++++++++++++++++++ trac é des courbes + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
23 figure ( figsize =(10 ,5))
24 subplots_adjust ( left = 0.04 , bottom = 0.05 , right = 0.97 , top = 0.97)
ELKIHEL

25 xlim (0 ,10)
26 ylim (0 , E )
27 grid ()
28 for i in range ( n ):
29 plot ( t_c [ i ] , u_c [ i ] , ’r - o ’ , label = ’ $u_c ( t ) $ ’)
30 pause (0.1)
31 for i in range ( n ):
32 plot ( t_d [ i ] , u_d [ i ] , ’r - o ’ , label = ’ $u_d ( t ) $ ’)
33 pause (0.1)
34 savefig ( ’ pdf / dipole - RC . pdf ’)
35 show ()

1.0

0.8

0.6

0.4
CPGE-MOHAMMEDIA

0.2

0.0
0 2 4 6 8 10
fig-9

Cinétique chimique - réactions successives

On considère l’équilibre schématisé par : A→B →C et de constantes de vitesse respectivesk1 et k2.
On pose [A]=x, [B]=y et [C]=z. Les équations qui régissent l’évolution temporelle du système sont :

15
 physique-chimie
dx

2 TSI-2


 =−k1.x
 dt



Python
dy
=k1.x−k2.y
 dt
 dz =k2.y



dt

réactions successives
1 import matplotlib . pylab as plt
2 from scipy . integrate import odeint
3 import numpy as np
4 from module_euler import euler
5 # ===============================================================
6 # on a plus qu ’ un varaible , donc la variable X est un vecteur
7 # c à d une liste X (x ,y , z ): X [0] = x , X [1] = y et X [2] = z
8 # ===============================================================
9 def F (X , t ) :
10 return - k1 * X [0] , - k2 * X [1] + k1 * X [0] , k2 * X [1]
11 # return dx / dt , dy / dt , dz / dt
12 # ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
13 k1 =2
14 k2 =1.5
15 # X0 =[2 ,0 ,0]
ELKIHEL

16 t = np . linspace (0 ,5 ,100)
17 X = euler (F ,[1 ,0 ,0] , t ). T
18 # +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
19 x ,y , z = X [0] , X [1] , X [2]
20 plt . figure ( figsize =(7 ,5))
21 plt . gcf (). subplots_adjust ( left = 0.08 , bottom = 0.05 , right = 0.97 ,\
22 top = 0.95 , wspace = 0.1 , hspace = 0)
23 plt . plot (t ,x , ’r -. ’ , label = ’A ( t ) ’)
24 plt . plot (t ,y , ’b - ’ , label = ’B ( t ) ’)
25 plt . plot (t ,z , ’g : ’ , label = ’C ( t ) ’)
26 plt . grid ()
27 plt . legend ()
28 plt . savefig ( ’ pdf / reactions_success ives . pdf ’)
29 plt . show ()

1.0

0.8

0.6
A(t)
CPGE-MOHAMMEDIA

B(t)
C(t)
0.4

0.2

0.0
0 1 2 3 4 5
8.2 Équations du deuxième ordre
À l’aide d’une résolution d’un système d’équations d’ordre 1 comme nous venons de les étudier, on peut résoudre par la
méthode d’Euler n’importe quelle équation du deuxième ordre. Il suffit de penser à prendre comme fonctions inconnues,

16
  
les deux fonctions y(t) et y0(t) Y =(y,y0)⇒Y 0 =(y0,y00) et de constater que l’équation du deuxième ordre peut s’écrire
 
y00(t)=F (y(t),y0(t)).

physique-chimie
Cas du pendule non linéaire : θ̈(t)+ω02.sin(θ(t))=0
2 TSI-2

Python
Pour reprendre les notations du paragraphe précédent, posons Y = (θ(t),  θ̇(t)), l’équation du pendule non linéaire
y(t)= θ̇(t)=Y [1]
θ̈(t)=−ω02.sin(θ(t)) est alors équivalente au système de deux équations
y0(t)= θ̈(t)=−ω02.sin(Y [0])

pendule non lineaire

1 from module_euler import euler

2 import numpy as np
3 # ---------------------------------------------------------
4
5 def F (y , t ) : # y =( x1 , x2 )=( theta , dtheta / dt )= > y ’=( dtheta / dt , d ^2 theta / dt ^2)
6 return y [1] , -w **2* np . sin ( y [0]) # return ( x ’ , x ’ ’)
7 #
8 # --------------------------------------------------------
9 w =1
10 n =100
11 T =2* np . pi / w
12 t = np . linspace (0 ,2* T , n )
13 Y = euler (F ,[3* np . pi /4 ,0] , t ). T # conditions initiales ( theta_0 , dtheta / dt_0 )
14 # on remarquera l ’ effet de theta_o sur la lin é arit é du pendule
15 # ( nmobre de p é riode d ’ oscillation )
16 # --------------------------------------------------------
ELKIHEL

17 from matplotlib import pyplot as plt

18 from pylab import *
19 # -------------------------------------------------------
20 plt . figure ( figsize =(10 , 5))
21 plt . subplot (121)
22 plt . title ( u " pendule non lin é aire " )
23 plt . xlim (0 , max ( t ))
24 plt . plot (t , Y [0] , ’r -. ’ , label = u " $ \ Theta ( t ) $ " )
25 plt . plot (t , Y [1] , ’b - ’ , label = u " $ \ omega ( t ) $ " ) # Commenter l ’ allure
26 legend ()
27 plt . subplot (122)
28 plt . title ( u " portrait de phase " )
29 plt . plot ( Y [0] , Y [1] , ’r - ’ , label = u " $ \ omega (\ Theta ) $ " ) # Commenter l ’ allure
30 legend ()
31 plt . savefig ( ’ pendule_non_lineaire . pdf ’)
32 plt . show ()

pendule non linéaire portrait de phase

2.0
( )
2 1.5

1.0
1
CPGE-MOHAMMEDIA

0.5

0 0.0

0.5
1
1.0

2 (t) 1.5
(t)
2.0
0 2 4 6 8 10 12 2 1 0 1 2

fig-4
π
En faisant tourner le code python précédent, avec les conditions initiales x0 = , on obtient la courbe suivante :
10
17
 physique-chimie
0.3 0.3 ( )
2 TSI-2

Python
0.2 0.2

0.1 0.1

0.0 0.0

0.1 0.1

0.2 0.2

0.3 0.3
0 5 10 15 20 0.3 0.2 0.1 0.0 0.1 0.2 0.3

fig-5

Oscillateur harmonique amorti

1 # +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
2 import numpy as np
3 # from matplotlib . pylab import plot
4 from pylab import *
ELKIHEL

5 from module_euler import euler

6 from scipy . integrate import odeint
7 # ----------------------------------------------------------------
8 def F (y , t ) : # y =( x , vx ) dx / dt = vx et ax = dvx / dt = -a * vx / Q - a **2* x
9 return y [1] , - w_o * m * y [1] - w_o **2* y [0] # retourne y ’= dy / dt , eqt - diff
10 # ----------------------------------------------------------------
11 w_o = 2 # pulsation propre
12 m = 0.5 # coefficient d ’ amortissement =1/( Q : facteur de qualit é )
13 w = w_o * sqrt (1 -( m **2/4) ) # pseudo pulsation
14 T =2* np . pi / w # pseudo - p é riode ,l ’ osscillateur arr ^ e te au bout de 5 T
15 n = 100 # à remarquer son effet sur l ’ approximation de la solution
16 t = np . linspace (0 ,3* T , n )
17 # ---------------------------------------------------------------
18 Y = euler (F ,[2 ,0] , t ). T # on applique la fonction euler avec condition
19 # initiale [2 ,0] c à d x0 =2 , vx0 =0
20 # +++++++++++++++ la courbe approximative Y ( T ) ++++++++
21 figure ( figsize =(10 ,5))
22 subplots_adjust ( left = 0.04 , bottom = 0.05 , right = 0.97 ,\
23 top = 0.97 , wspace = 0.1 , hspace = 0)
24 subplot (121)
25 xlim (0 , max ( t ))
26 plot (t , Y [0]/ max ( Y [0]) , ’r - ’ , label = u " $x ( t )/ x_ { max } $ " ) # la courbe x ( t )
27 plot (t , Y [1]/ max ( Y [1]) , ’b -. ’ , label = u " $Vx ( t )/ V_ { max } $ " ) # la courbe vx ( t )
28 legend ()
29 grid ()
CPGE-MOHAMMEDIA

30 subplot (122)
31 plot ( Y [0] , Y [1] , ’r - ’ , label = u " Vx ( x ) " ) # la courbe approximative
32 legend ()
33 grid ()
34 savefig ( ’ o s ci l l at e u r_ m o du l e _e u l er . pdf ’)
35 show ()

18
 1.0 x(t)/xmax Vx(x)
Vx(t)/Vmax

physique-chimie
1
2 TSI-2

0.5

Python
0.0 0

0.5
1
1.0

1.5 2

2.0

3
0 2 4 6 8 1.0 0.5 0.0 0.5 1.0 1.5 2.0
fig-6
8.3 Utilisation de la fonction odeint du module scipy.integrate
La démarche précédente se trouve dans le module scipy.integrate. En fait, c’est très simple puisque l’unique fonction
odeint sert à résoudre toutes les équations différentielles, et fonctionne sur le même mode que notre fonction euler : on
ELKIHEL

lui donne une fonction F (éventuellement vectorielle) représentant l’équation (ou le système), une condition initiale y0
(qui sera un vecteur dans le cas d’un système), et un tableau de nombres correspondant aux valeurs tk pour les quelles
on souhaite calculer une valeur approchée de yk (tk ), et la fonction ressort un tableau de valeurs qu’on peut évidemment
représenter graphiquement si on le souhaite.

oscillateur avec la fonction odeint

1 # +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
2 import numpy as np
3 from matplotlib . pylab import plot as plt
4 from pylab import *
5 from module_euler import euler
6 from scipy . integrate import odeint
7 # ----------------------------------------------------------------
8 def F (y , t ) : # y =( x , vx ) dx / dt = vx et ax = dvx / dt = -a * vx / Q - a **2* x
9 return y [1] , - w_o * m * y [1] - w_o **2* y [0] # retourne y ’= dy / dt , eqt - diff
10 # ----------------------------------------------------------------
11 w_o = 2 # pulsation propre
12 m = 0.2 # coefficient d ’ amortissement =1/( Q : facteur de qualit é )
13 w = w_o * sqrt (1 -( m **2/4) ) # pseudo pulsation
14 T =2* np . pi / w # pseudo - p é riode ,l ’ osscillateur arr ^ e te au bout de 5 T
15 n = 500 # à remarquer son effet sur l ’ approximation de la solution
16 t = np . linspace (0 ,7* T , n )
17 # ---------------------------------------------------------------
18 Y = odeint (F ,[2 ,0] , t ). T # on applique la fonction odeint avec condition
CPGE-MOHAMMEDIA

19 print ( Y )
20 # initiale [2 ,0] c à d x0 =2 , vx0 =0
21 # +++++++++++++++ la courbe approximative Y ( T ) +++++++++++++++++++
22 plt . figure ( figsize =(10 ,5))
23 plt . gcf (). subplots_adjust ( left = 0.04 , bottom = 0.05 , right = 0.97 ,\
24 top = 0.97 , wspace = 0.1 , hspace = 0)
25 plt . subplot (121)
26 plt . xlim (0 , max ( t ))
27 plt . plot (t , Y [0]/ max ( Y [0]) , ’r - ’ , label = u " $x ( t )/ x_ { max } $ " ) # la courbe x ( t )
28 plt . plot (t , Y [1]/ max ( Y [1]) , ’b -. ’ , label = u " $Vx ( t )/ V_ { max } $ " ) # la courbe vx ( t )
29 legend ()
30 plt . grid ()
31 plt . subplot (122)

19
 physique-chimie
32 plt . plot ( Y [0] , Y [1] , ’r - ’ , label = u " Vx ( x ) " ) # la courbe approximative
2 TSI-2

33 legend ()

Python
34 plt . grid ()
35 plt . savefig ( ’ os c i ll a t eu r _ eu l e r_ o d ei n t . pdf ’)
36 plt . show ()

1.0 x(t)/xmax Vx(x)

Vx(t)/Vmax
2

0.5
1

0.0 0

1
0.5

2
1.0
3
ELKIHEL

0.0 2.5 5.0 7.5 10.0 12.5 15.0 17.5 20.0 1.5 1.0 0.5 0.0 0.5 1.0 1.5 2.0
fig-7
Conclusion : le modèle d’Euler et la fonction odeint donnent les mêmes résultats.
8.4 Oscillateur amorti-animation

oscillateur - animation
1 from matplotlib import pyplot as plt
2 import numpy as np
3 from pylab import *
4 from scipy . integrate import odeint
5 # ----------------------------------------------
6 a , w_o = 0.1 ,2 # commenter l ’ allure des courbes en fonction a >1/2 , a =1/2 , a <1/2
7 omega0 = w_o
8 alpha = a
9 T = 2* np . pi / w_o
10 # --- X =[ u_c , du_c / dt ] = > X ’=[ du_c / dt , -2* a * w_o * X [1] - w_o **2* X [0]
11 def F (X , t ) :
12 return ( X [1] , -2* a * w_o * X [1] - w_o **2* X [0])
13 # --- [2 ,0] = > u_co =2 , i_o = 0 , on cherche u_c et i
14 tf =2* T # on observe 2 p é riodes d ’ oscillations
CPGE-MOHAMMEDIA

15 n =100
16 t = np . linspace (0 , tf , n )
17 X = odeint (F ,[2 ,0] , t ). T
18 u_c , i = X [0] , X [1]
19 # - - - - - - - - - - - - - - - - - - - - - - trac é des courbes -- --- ---- --
20 plt . figure ( figsize =(10 ,5))
21 plt . gcf (). subplots_adjust ( left = 0.04 , bottom = 0.05 , right = 0.97 , top = 0.95 ,
22 wspace = 0.1 , hspace = 0)
23
24 plt . subplot (121)
25 plt . xlim (0 , tf )
26 plt . plot (t , u_c , ’b - ’ , label = u " $u_c$ ( t ) " )
27 plt . grid ()
28 legend ()

20
 physique-chimie
29 plt . subplot (122)
2 TSI-2

30 plt . title ( ’ portrait de phase $i ( u_c ) $ ’)

Python
31 plt . xlim (1.1* min ( u_c ) ,1.1* max ( u_c ))
32 plt . ylim (1.1* min ( i ) ,1.1* max ( i ))
33 plt . grid ()
34 for n in range ( n ):
35 plt . plot ( u_c [ n ] , i [ n ] , ’r - o ’ , label = u " $i ( u_c ) $ " )
36 plt . pause (0.01)
37 plt . savefig ( ’ oscillateur_animat ion . pdf ’)
38 plt . show ()

courbe i(u_c)
2.0 uc(t)
2
1.5
1
1.0

0.5 0

0.0 1
ELKIHEL

0.5 2

1.0
3
1.5
0 1 2 3 4 5 6 1.5 1.0 0.5 0.0 0.5 1.0 1.5 2.0
fig-8
8.5 Oscillateur de Wien

Oscillateur de Wien
1 " " " l ’é quation de l ’ oscillateur de Wien est :
2 d2Vs / dt2 + (3 k -1)/( k * tau ) dVs / dt + Vs / tau2 =0
3 avec k = R1 /( R1 + R2 ) et tau = RC " " "
4 # ========================================================
5 import numpy as np
6 def F (y , t ) : # on pose y =[ Vs , dVs / dt ] = > y ’=[ dVs / dt , d2Vs / dt2 ]
7 return y [1] , -(3* k -1)* y [1]/( k * tau ) -y [0]/ tau **2
8 # ======================================================
9 R =1000 # 1 k
10 R1 , R2 = R ,2.2* R
11 k , C = R1 /( R1 + R2 ) , 10**( -6)
12 tau = R * C
CPGE-MOHAMMEDIA

13 w_o = 1/ tau
14 T =2* np . pi / w_o
15 print ( T , 1/ T )
16 # ========================================================
17 from scipy . integrate import odeint
18 from pylab import *
19 # ========================================================
20 n =500
21 t = np . linspace (0 ,20* T , n )
22 X = odeint (F ,[0 ,12] , t ). T
23 # ========== On remplace les valeurs de Vs > ou < + Vsat ou - Vsat ======
24 Vs = X [0] # = un np . array
25 for x in Vs :
26 if x >=12 :

21
 physique-chimie
27 Vs [ np . where ( Vs == x )]=12
2 TSI-2

28 elif x <= -12:

Python
29 Vs [ np . where ( Vs == x )]= -12
30 else :
31 pass
32 # =================== On trace la courbe Vs ( t ) ==================
33 figure ( figsize =(10 ,5))
34 subplots_adjust ( left =0.05 , right =0.97 , bottom =0.05 , top =0.95)
35 # ========================================================
36 plot (t , Vs , ’r - ’ , label = " tension $V_s ( t ) $ " )
37 title ( " Oscillateur de Wien " )
38 legend ()
39 savefig ( " oscillateur_wien . pdf " )
40 show ()

Oscillateur de Wien
tension Vs(t)
10

5
ELKIHEL

10

0.00 0.02 0.04 0.06 0.08 0.10 0.12

fig-14 :
Oscillateurs de Wien
8.6 Frottement fluide
#–
Chute d’une bille avec frottement fluide du type f =−α #–
v.

Frottement fluide
1 from module_euler import euler
2 from scipy . integrate import odeint
3 # +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
4 import numpy as np
5 from matplotlib import pyplot as plt
CPGE-MOHAMMEDIA

6 from pylab import *

7 # ------------------------------------------------------------------------
8 def F (Y , t ) : # Y =( x ,y , vx , vy ) dx / dt = vx , dy / dt = vy , ax = - a * vx , ay = - b * vy -g
9 return Y [2] , Y [3] ,- a * Y [2] , -b * Y [3] - g # retourne y ’= dy / dt , eqt - diff
10 # ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11 a , b , g , n = 1 , 1 , 10 , 100 # remarquer l ’ effet du frottement si a != b (a > b )
12 t = np . linspace (0 ,10 , n )
13 # ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
14 Y = euler (F ,[0 ,0 ,50 ,50] , t ). T # x =0 , y =0 , vx0 =50 , vy0 =50 ( alpha = 45)
15 # - - - - - - - - - - - - - - - - - - - - - trac é des courbes - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
16 plt . figure ( figsize =(10 ,5))
17 plt . gcf (). subplots_adjust ( left = 0.04 , bottom = 0.05 , right = 0.97 ,\
18 top = 0.97 , wspace = 0.15 , hspace = 0.2)
19 plt . subplot (131)

22
 physique-chimie
20 plt . plot (t , Y [1] , ’b -. ’ , label = ’y ( t ) ’)
2 TSI-2

21 plt . plot (t , Y [0] , ’r - ’ , label = ’x ( t ) ’)

Python
22 plt . grid ()
23 plt . legend ()
24 plt . subplot (132)
25 plt . plot ( Y [0] , Y [2] , ’r - ’ , label = ’ Vx ( x ) ’)
26 plt . plot ( Y [0] , Y [3] , ’b -. ’ , label = ’ Vy ( x ) ’)
27 plt . grid ()
28 plt . legend ()
29 plt . subplot (133)
30 plt . plot ( Y [1] , Y [2] , ’r - ’ , label = ’ Vx ( y ) ’)
31 plt . plot ( Y [1] , Y [3] , ’b -. ’ , label = ’ Vy ( y ) ’)
32 plt . grid ()
33 plt . legend ()
34 plt . savefig ( ’ c h u t e _ p a r a b o l i q u e _ f r o t t e m e n t _ f l u i d e . pdf ’)
35 plt . show ()

50 Vx(x) 50 Vx(y)
Vy(x) Vy(y)
40
40 40
ELKIHEL

20 30 30

20 20
0
10 10

20
0 0

y(t)
40 x(t) 10 10
0 2 4 6 8 10 0 10 20 30 40 50 40 20 0 20
fig-10
8.7 Mouvement à force centrale

Force centrale
#– #–
ur
Un mobile M(x,y) dans un champ newtonien F =−k 2 de centre attracteur C(xc,0) a pour équation de mouvement
r
k.(x−x c)

 m.ax =−

3

((x−xc) +y2) 2
2
CPGE-MOHAMMEDIA

en coordonnées cartésiennes : k.y

 m.ay =−

 3
((x−xc)2 +y2) 2
1 - Écrire un programme python pour tracer la trajectoire y(x) du mobile avec m=1, k=1 (valeurs non réalistes).
k
ordre de grandeur pour le champ terrestre : =G.Mt =4.1014 .
m
2 - Proposer, en se basant sur les paramètres caractéristiques des deux trajectoires circulaire et elliptique, une
méthode pour vérifier la troisième loi de Kepler, (conditions initiales ro par rapport à C et vo en fonction de ro).
On rappelle que :
ro.vo2
- Aux conditions initiales la norme du vecteur excentricité est e=| −1| et la constante des aires est C =ro.vo.
G.Mt
k v 2 2
mC (1−e ) 2
- Em =− +m. o =− .
ro 2 2p2

23
 physique-chimie
- On a les paramètres de l’ellipse : p=C 2/G.Mt ; a=p/(1−e2) ; b=(a.p)0.5 ; S =ab.π ; T =2.S/C.
2 TSI-2

- Choisissez vo et ro =xo pour fixer le signe de Em et par la suite savoir si le système est lié ou non ⇒ la nature de

Python
la trajectoire.
k
- a= 2.k avec k =1⇒ nature de la trajectoire !!!
2
ro −m.vo r
1 G.Mt
1 - si e=0:a=ro et Em =− ⇒vo = ⇒ trajectoire circulaire.
r 2ro ro
G.Mt p
2 - si e<1:Em <0 et <vo < 2G.Mt/ro ⇒ trajectoire elliptique.
rp
o
3 - si e=1:Em =0 et vo = p2G.Mt/ro ⇒ trajectoire parabolique.
4 - si e>1:Em >0 et vo > 2G.Mt/ro ⇒ trajectoire hyperbolique.
Vérification de la 3e loi de Kepler
La condition surp vo en fonction de ro donne la nature de la trajectoire.
On pose vo = α/ro avec α<2 : cas de la trajectoire elliptique.
Mise en équations
On pose Y =(x,y,vx,vy )⇒Y 0 =(x0,y0,ax,ay ). On définit une fonction qui retourne les équations suivantes :
dx #– #–
ur dvx dvy
= Y [2] ; dy/dt = Y [3] et puisque F = −k 2 = f(x,y) , on a = ax = fct(Y [0],Y [1]) et = ay =
dt r dt dt
fct(Y [0],Y [1])
Le principe est de calculer Y (tk+1)=Y (tk )+dt.Y 0(tk ) pour k ≥0 avec Y 0 =F (Y,t).

Force centrale en coordonnées cartésiennes

ELKIHEL

1 import numpy as np
2 from pylab import *
3 from moduleEuler import euler
4 from scipy . integrate import odeint
5 # =============================================
6
7 def F (Y , t ) : # Y =[ x ,y , Vx , Vy ]
8 return ( Y [2] , Y [3] ,
9 -k *( Y [0] - xc )/(( Y [0] - xc )**2 + ( Y [1] - yc )**2)**1.5 ,
10 -k * Y [1]/(( Y [0] - xc )**2 + ( Y [1] - yc )**2)**1.5) # vx , vy , ax , ay
11 # ===========================================================
12 m , k =1 , 1
13 xc , yc = 0 ,0 # origine du r é f é rentiel
14 xo , yo = 3 ,0 # point de d é part du mobile
15 theta_o = np . pi /4 # direction de la vitesse par rapport à Ox
16 ro = sqrt (( xo - xc )**2 + ( yo - yc )**2)
17 cos = ( xo - xc )/ ro
18 sin = abs ( yo - yc )/ ro
19 # ===========================================================
20 def vitesse ( alpha , ro ) : # alpha =1 pour une trajectoire circualire
21 return sqrt ( alpha / ro ) # alpha < 2 pour une trajectoire é lliptique
22 # alpha =2 pour une trajectoire parabolique
23 # alpha > 2 pour une trajectoire hyperbolique
CPGE-MOHAMMEDIA

24 # =============== Trajectoire circualire = = = = = = = = = = = = = = = = = = = = = = = = = = =

25 v_c = vitesse (1 , ro ) # vitesse du mouvement circulaire
26 vx_c = - sin * v_c
27 vy_c = cos * v_c
28 T_c = 2* np . pi * ro / v_c # p é riode du mouvement circulaire
29 # = = = = = = = = = = = = = = = = = = = = = = = = = = = = = Trajectoire é lliptique =============
30 v_e = vitesse (1.5 , ro ) # vitesse du mouvement é lliptique
31 vx_e = - sin * v_e
32 vy_e = cos * v_e
33 e = abs (( ro / k )*( m * v_e **2) -1)
34 print ( e )
35 C = ro * v_e # constante des aires dans le cas de l ’ ellipse
36 p = C **2 # le param è tre de l ’ ellipse avec G * M =1

24
 physique-chimie
37 a = p /(1 - e **2) # le demi - grand axe de l ’ ellipse
2 TSI-2

38 b = ( a * p )**0.5 # le demi - petit axe de l ’ ellipse

Python
39 S_e = a * b * np . pi # surface de l ’é llipse
40 T_e = 2* S_e / C # p é riode du mouvement é lliptique ( la p é riode de la tr
41 # ajectoire !!!)
42 # print (" la 3 loi de Kepler = > ro **3/ T_c **2 = " , ro **3/ T_c **2 ," = a **
43 # 3/ T_e **2 = " , a **3/ T_e **2 ," = 1/(4* np . pi **2) = " ,1/(4* np . pi **2))
44 # = = = = = = = = = = = = = = = = = = = = = = = = = = = = = Trajectoire parabolique =============
45 v_p = vitesse (2 , ro ) # vitesse du mouvement é lliptique
46 vx_p = - sin * v_p
47 vy_p = cos * v_p
48 # = = = = = = = = = = = = = = = = = = = = = = = = = = = = = Trajectoire hyperbolique =============
49 v_h = vitesse (2.5 , ro ) # vitesse du mouvement é lliptique
50 vx_h = - sin * v_h
51 vy_h = cos * v_h
52 # ===============================================
53 def tracer ( x , y , v_x , v_y , couleur ) :
54 X = euler (F ,[ x ,y , v_x , v_y ] , t ). T
55 print ( " vx_fin = " , X [2][ -1] , " vy_fin = " , X [3][ -1])
56 # euler (). T retourne la solution X (x ,y , vx , vy ) comme odeint ()
57 # X [0] les valeurs de x et X [1] les valeurs de y
58 plot ( xc ,0 , ’r - o ’) # on trace le centre attracteur
59 annotate ( ’C ’ , xy =( xc ,0.5))
60 xlim ( min ( X [0]) , max ( X [0]))
ELKIHEL

61 ylim ( min ( X [1]) , max ( X [1]))

62 for i in range ( len ( X [0])):
63 plot ( X [0][ i ] , X [1][ i ] , couleur )
64 # On trace la trajectoire point par point
65 pause (0.1) # intervalle de pause
66
67 # # =========== trajectoires circulaire et elliptique ===============
68 figure ( figsize =(10 ,5)) # ==========
69 subplots_adjust ( left =0.05 , bottom =0.05 , right =0.97 , top =0.9 , wspace =0.1 , hspace = 0.2)
70 N =50
71 subplot (121) # subplot (221)
72 axis ( ’ square ’)
73 title ( " Trajectoires circulaire et é lliptiuqe : " + " $ \ dfrac { a ^3}{ T ^2}= $ " + str ( round ((( ro
74 t = np . linspace (0 , T_c , N )
75 tracer ( xo , yo , vx_c , vy_c , ’r - o ’) # vo = ( k / ro )**0.5
76 t = np . linspace (0 , T_e , N )
77 tracer ( xo , yo , vx_e , vy_e , ’b - o ’) # v_e < (2/ ro )**0.5
78 # ======== trajectoires parabolique et hyperbolique =================
79 subplot (122)
80 title ( " Trajectoires parabolique et hyperbolique " )
81 t = np . linspace (0 ,2* T_e , N )
82 tracer ( xo , yo , vx_p , vy_p , ’r - o ’ ) # vo = (2 k / ro )**0.5
83 tracer ( xo , yo , vx_h , vy_h , ’b - o ’) # vo > (2 k / ro )**0.5
84 savefig ( " pdf / for ce_c ent ral e_co urb es . pdf " )
85 show ()
CPGE-MOHAMMEDIA

25
 Trajectoires parabolique et hyperbolique
Trajectoires circulaire et élliptiuqe:aT 2 = 0.02533
3
70

physique-chimie
2 TSI-2

4 60

Python
50
2

C 40
0
30
2
20

4 10

8 6 4 2 0 2 C
50 40 30 20 10 0
fig-11

Force centrale - formules de Binet

1 import numpy as np
2 import pylab as plt
3 from moduleEuler import euler
4 from scipy . integrate import odeint
ELKIHEL

5 # ==================== Mouvement à force centarle =========

6 # v_r = -C . u ’ , v_theta = C . u : formule de Binet de la vitesse
7 # Equation diff é rentielle avec les formules de Binet :
8 # u ’ ’( theta ) + u ( theta )=1/ p avec p = C **2/ GM
9 # ======================================================
10 def F (y , theta ) : # y = [u , du / d_theta ] - > y ’ = [ u ’= y [1] , u "= -u -1/ p ]
11 return y [1] ,-y [0] + 1/ p
12 # ======================================================
13 m , k = 1, 1
14 ro = 1
15 alpha = 1.7 # alpha < 2 pour une trajectoire é lliptique ! param è tre
16 # de la simulation à faire varier
17 # alpha = 1 pour une trajectoire circulaire
18 vo = np . sqrt ( alpha / ro ) # vitesse initiale du mouvement é lliptique
19 e = abs (( ro / k )*( m * vo **2) -1)
20 print ( ’ excentricit é e = ’ , e )
21 C = ro * vo # constante des aires dans le cas de l ’ ellipse
22 p = C **2 # le param è tre de l ’ ellipse avec G * M =1
23 a = p /(1 - e **2) # le demi - grand axe de l ’ ellipse
24 b = p /(1 - e **2)**0.5 # le demi - petit axe de l ’ ellipse
25 S_e = a * b * np . pi # surface de l ’é llipse
26 T_e = 2* S_e / C
27 # p é riode du mouvement é lliptique (= la p é riode de la trajectoire !!!)
28 # print (" la 3 loi de Kepler = > = a **3/ T_e **2 = " , a **3/ T_e **2 ,"
CPGE-MOHAMMEDIA

29 # = 1/(4* np . pi **2) = " ,1/(4* np . pi **2))

30 N =50
31 theta = np . linspace (0 ,2* np . pi , N ) # )
32 # u_1 = odeint (F ,[1/ ro , e * np . sin ( np . pi )/ p ] , theta ). T
33 u = euler (F ,[1/ ro , e * np . sin ( np . pi )/ p ] , theta ). T
34 # print ( u_1 - u )
35 # print (" voil à " , len ( u ))
36 # [ u (0) , du / d_theta (0)] = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
37 w = C * u [0]**2
38 d_theta = theta [2] - theta [1]
39 dt = d_theta / w
40 T = np . sum ( dt ) # p é riode du mouvement
41 print ( T / T_e )
42 r = 1/ u [0]

26
 physique-chimie
43 x = r * np . cos ( theta )
2 TSI-2

44 y = r * np . sin ( theta )

Python
45 # =================== vitesse =====================
46 v_r = -C * u [1]
47 v_theta = C * u [0]
48 v_x = v_r * np . cos ( theta ) - v_theta * np . sin ( theta )
49 v_y = v_r * np . sin ( theta ) + v_theta * np . cos ( theta )
50 # ================= acc é l é ration == ==== === === ==== === ===
51 a = -C **2* u [0]**2/ p
52 a_x = a * np . cos ( theta )
53 a_y = a * np . sin ( theta )
54 # ====================================================================
55 plt . figure ( figsize =(7 ,5)) # ======
56 plt . subplots_adjust ( left =0.05 , bottom =0.05 , right =0.97 ,
57 top =0.9 , wspace =0.1 , hspace = 0)
58 plt . axis ( ’ square ’) # m ^ e me unit é des axes pour voir la forme é lliptique
59 plt . title ( " Trajectoire é lliptique " + " $ \ dfrac { a ^3}{ T_e ^2}= $ " +
60 str (( ro )**3/( T_e )**2 ))
61 plt . plot (0 ,0 , ’ go ’)
62 plt . annotate ( ’C ’ , xy =(0 ,0.1))
63 plt . xlim (1.1* min ( x ) , 1.5* max ( x ))
64 plt . ylim (1.1* min ( y ) , 1.1* max ( y ))
65 for k in range ( len ( x )):
66 plt . plot ( x [ k ] , y [ k ] , ’ ro ’)
ELKIHEL

67 if k %2==0: # on trace le vecteur vitesse pour un point sur 2.

68 plt . arrow ( x [ k ] , y [ k ] , v_x [ k ] , v_y [ k ] , head_width =0.05 , color = ’b ’)
69 plt . arrow ( x [ k ] , y [ k ] ,2* a_x [ k ] ,2* a_y [ k ] , head_width =0.05 , color = ’g ’)
70 # plt . annotate ( ’ V ’, xy =( x [ k ] , y [ k ]))
71 else :
72 pass
73 plt . pause (0.1)
74 plt . savefig ( ’ force_centrale_binet . pdf ’)
75 plt . show ()

Trajectoire élliptique aT 2 = 0.0006839179895857801

3
e
2

C
0

1
CPGE-MOHAMMEDIA

6 5 4 3 2 1 0 1
fig-12 :
force centrale : vecteurs vitesse et accélération

27
 physique-chimie
9 Filtrage
2 TSI-2

Recomposition d’un signal

Python
1 # CPGE MOHAMMEDIA
2 # 2 TSI2
3 # recomposition d ’ un signal cr é neau alternatif
4
5 import numpy as np
6 from pylab import *
7
8
9 E =1
10 f0 =100 # fr é quence du cr é neau
11 T =0.01
12 w0 =2* np . pi / T
13 N = 10 # nombre d ’ harmoniques
14 n = np . arange (1 , N ) # les indices n
15
16 # d é fintion des coefficients Cn
17 def Cne ( n ) :
18 return 4*(1 -( -1)** n )/(( n * np . pi )**2)
19 # recomposition du signal cr é neau
20
ELKIHEL

21 # d é fintion des harmoniques hk

22 def hk (t ,k , w ) :
23 return ( Cne ( k ))* np . cos (( k * w * t ))
24
25 # somme des harmoniques hk = s ( t )
26
27 def s ( t ) :
28 s = 0.0
29 for k in range (1 , N ):
30 h = hk (t ,k , w0 )
31 s += h
32 return s
33
34 # Trac é du spectre en fr é quence :
35
36
37 # clf () # effacer la courbe
38 figure ( figsize =(12 ,6))
39 subplots_adjust ( left =0.05 , right =0.95 , top =0.93 , bottom =0.05 , wspace =0.2 , hspace =0.25)
40 subplot (231)
41 grid ()
42 stem ( n , Cne ( n ) , ’b - ’)
43 title ( " spectre d ’ un signal cr é neau $ \ dfrac { C_ { ne }}{ E }( w ) $ " )
44
45 # show ()
CPGE-MOHAMMEDIA

46
47
48
49 # Tracer la courbe somme des N harmoniques
50 subplot (232)
51 t = np . linspace ( -0.02 ,0.02 ,200)
52 grid ()
53 plot (t , s ( t ))
54 title ( u " somme partielle des harmoniques $V_s ( t ) $ " )
55 # ======== effet d ’ un filtre selectif sur le signal cr é neau
56 wc = w0 # wc pulsation caract é ristique du filtre
57 Q =10
58 def H ( w ) : # d é finition de la fonction de transfert complexe

28
 physique-chimie
59 return 1/(1+1 j * Q *( w / wc - wc / w ))
2 TSI-2

60 # ============= diagramme de Bode en gain

Python
61 def G ( w ) :
62 return 20* log10 ( abs ( H ( w )))
63
64 subplot (233)
65 w = linspace (1 ,1 e4 ,1000)
66 semilogx ( w , G ( w ))
67 title ( ’ diagrame de bode : G ( w ) ’)
68 grid ()
69 # faites varier la valeur de Q et remarquer l ’ effet sur la largeur de la ban
70 # de passante dans le diagramme de bode ( l ’ effet s é lectif du filtre )
71 # spectre du signal de sortie Cns ( n . w0 )= H ( n . w0 , Q ). Cne ( n ) :
72 # les coefficient Cns :
73
74 def Cns ( n ) :
75 return abs ( H ( n * w0 )* Cne ( n ))
76
77 # courbe Cns ( n ) ( l ’ harmonique retenu par le filtre est h3 = h (3 f0 ) d ’ amlitude C
78 subplot (234) # 3 s )
79 stem ( n , Cns ( n ))
80 title ( ’ courbe : $ \ dfrac { C_ { ns }}{ E } $ ( n ) ’)
81 grid ()
82 # show ()
ELKIHEL

83 # remarquer le lien entre le spectre de sortie et la fr é quence caract é rist

84 # ique du filtre
85
86 # la phase phi_sn = phi_en + arg ( H ( jx )) avec phi_e ( n )=0
87 def phi_s ( n ) :
88 return angle ( H ( n * w0 ) , deg =0) # deg =0 = > phi_s ( n ) en radian
89
90 subplot (235)
91 stem ( n , phi_s ( n ))
92 xlabel ( ’n ’)
93 title ( ’ spectre $ \ phi_ { sn } $ ( rad ) ’)
94 grid ()
95 # show ()
96
97 # somme des harmoniques sn
98
99 def Vs ( t ) :
100 vs = 0.0
101 for n in range (1 , N ):
102 sn = Cns ( n )* np . sin ( n * w0 * t +( phi_s ( n ))) # harmonique sn
103 vs = vs + sn
104 return vs
105
106 # Tracer la courbe somme Vs ( t ) des N harmoniques
107
CPGE-MOHAMMEDIA

108 # t = linspace ( -0.005 ,0.005 ,200)

109 subplot (236)
110 t = linspace ( -0.01 ,0.01 ,200)
111 xlim ( -0.01 ,0.01)
112 plot (t , Vs ( t ))
113 title ( ’ la r é ponse du filtre $V_s ( t ) $ avec $w_c = w_0$ ’)
114 grid ()
115 savefig ( ’ pdf / r e c o m p o s i t i o n _ t r i a n g u l a i r e . pdf ’)
116 show ()
117
118 # remarquer le lien entre la fr é quence du signal de sortie et la fr é quence
119 # caract é ristique du filtre ( prendre wc = w0 )
120

29
 physique-chimie
121 # Exercice : Etudier l ’ effet d ’ un filtre passe - bas de f é quence de coupure
2 TSI-2

122 # f0 sur le signal cr é neau

Python
spectre d'un signal créneau CEne (w) somme partielle des harmoniques Vs(t) diagrame de bode : G(w)
0.8 1.0 0

0.6 0.5 20

0.4 0.0 40

0.2 0.5 60
0.0 1.0
2 4 6 8 0.02 0.01 0.00 0.01 0.02 100 101 102 103 104
courbe : CEns (n) spectre sn(rad) la réponse du filtre Vs(t) avec wc = w0
0.8 0.00 0.75
0.25 0.50
0.6
0.50 0.25
0.4 0.75 0.00
1.00 0.25
0.2 1.25 0.50
1.50 0.75
ELKIHEL

0.0
2 4 6 8 2 4 6 8 0.010 0.005 0.000 0.005 0.010
n
fig-13 :
recomposition d’un signal triangulaire

10 Ondes

Onde progressive

1 from pylab import *

2 import numpy as np
3 # Les fonctions - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
4 def tracer (x , y , amplitude , x_max , x_point , y_point ) :
5 clf ()
6 title ( " Repr é sentation de l ’ onde " )
7 xlabel ( " D é placement ( en m ) " )
8 xlim (0 , x_max )
9 ylabel ( " Amplitude " )
10 ylim ( -2* amplitude ,2* amplitude )
11 grid ()
12 plot (x , y , color = ’ red ’)
13 plot ( x_point , y_point , ’ bo ’)
14 pause (0.01)
15 # Le programme principal - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
CPGE-MOHAMMEDIA

16 A =3
17 T =2
18 v =5
19 x_max =50
20 xP =20
21 t = np . linspace (0 ,10 ,100)
22 x = np . linspace (0 , x_max ,100* x_max )
23 for i in range ( len ( t )):
24 y = A * np . sin ((2* np . pi / T )*( t [ i ] - x / v ))
25 yP = A * np . sin ((2* np . pi / T )*( t [ i ] - xP / v ))
26 tracer (x ,y ,A , x_max , xP , yP )
27 savefig ( ’ pdf / onde_progressive . pdf ’)
28 show ()

30
 Représentation de l'onde
6

physique-chimie
2 TSI-2

Python
2

Amplitude
0

6
0 10 20 30 40 50
Déplacement (en m)
fig-14 :
onde progressive

11 Interférences lumineuses

Interférences lumineuses
1 import numpy as np
2 import pylab as plt
ELKIHEL

3 # ================== fonctions de l ’ illustration = = = = == = = = = = = = = = = = = = = = = = = =

4 def d_young ( x ) : # diff é rence de marche dans le cas des trous de Young
5 return a * x / D
6 def d_Michelson ( r ) : # diff é rence de marche dans le cas du Michelson en lame d ’ air
7 return 2* e *(1 - r **2/(2* D **2))
8 def I ( difference_marche , lambda_o ) : # la formule de Fresnel de l ’ intensit é I ( M )
9 return 2* I_o *(1 + np . cos (2* np . pi * difference_marche / lambda_o ))
10 # ================= param è tres de la simulation = == == == = == == == == == == == =
11 ( D , a , I_o ) =(2 , 0.5*10**( -3) , 1 ) # param è tres de la simulation
12 ( l_b , l_v , l_r )=(470*10**( -9) , 530*10**( -9) , 632*10**( -9))
13 # les longueurs d ’ ondes dans le vide : bleue , verte et rouge
14 # =================================================
15 i_r = l_r * D / a # la plus grande interfrange dans le cas des trous de Young
16 N =100 # nombre de points du trac é
17 # =============== trac é des courbes = = = = = = = = = = = = = = = = = = = = = = = = = =
18 plt . figure ( figsize =(12 ,5))
19 plt . subplots_adjust ( left = 0.04 , right = 0.96 , bottom = 0.05 ,\
20 top = 0.94 , wspace = 0.15 , hspace = 0) # ajustement de la figure
21 # ====================================================
22 X = np . linspace ( -2* i_r ,2* i_r , N ) # l ’ intervalle des x =4 interfranges du rouge
23 I_m = max ( I ( d_young ( X ) , l_r )) # l ’ intensite maximale
24 #x <=5 interfranges assure un bon trac é des franges
25 # ===== ========= Source monochromatique == === ==== === ==== === ===
26 plt . subplot (131) # trois figure : monochromatique , polychromatique , Michelson
CPGE-MOHAMMEDIA

27 plt . title ( " Source monochromatique " )

28 plt . plot (X , I ( d_young ( X ) , l_r )/ I_m , ’r - ’) # courbe intensit é r é duite
: I_r ( x )/ I_m <= 1
29 # ==== on trace la teinte d é grad é e au dessus de la courbe I_r ( x ) =============
30 x = X [0]
31 dx = 0.1*( X [1] - X [0]) # valeur faible pour avoir une continuit é de la teinte d é grad é e
32 while x <= max ( X ):
33 plt . plot ([ x , x ] ,[1 ,2] , color =( I ( d_young ( x ) , l_r )/ I_m ,0 ,0) , linewidth =2)
34 # des segments [ x1 , x2 ] - >[ y1 , y2 ] de coleur color =( R = I ( x )/ I_m , G =0 , B =0)
35 x += dx
36 # ============ Source polychromatique = = = == = = = = = = = = = = = = = = = = = = = =
37 # On supperpose les trois courbes des radiations rouge , verte et bleue
38 plt . subplot (132)
39 plt . title ( " Source polychromatique " )

31
 physique-chimie
40 plt . plot (X , I ( d_young ( X ) , l_r )/ I_m , ’r - ’) # radiation rouge I_r ( x )
2 TSI-2

41 plt . plot (X , I ( d_young ( X ) , l_v )/ I_m , ’g - ’) # radiation verte I_v ( x )

Python
42 plt . plot (X , I ( d_young ( X ) , l_b )/ I_m , ’b - ’) # radiation blue I_b ( x )
43 # ====================================================
44 x = X [0] # on trace la teinte d é grad é e ( RGB ) au dessus des courbes I ( x )
45 while x <= max ( X ):
46 plt . plot ([ x , x ] ,[1 ,2] , color = ( I ( d_young ( x ) , l_r )/ I_m , I ( d_young ( x ) , l_v )/ I_m ,
47 I ( d_young ( x ) , l_b )/ I_m ) , linewidth =2)
48 # des segments d é grad é s [ x1 , x2 ] - >[ y1 , y2 ]
49 x += dx
50 # =========== Michelson en lame d ’ air = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
51 ( e , D ) = ( 0.005 , 1 )
52 i_2 = D * np . sqrt ( l_r / e )*( np . sqrt (2) -1) # interfrange 1 - >2
53 # ===========================================================
54 plt . subplot (133)
55 plt . axis ( ’ equal ’)
56 R = np . linspace (0 , 6* i_2 , N )
57 theta = np . linspace (0 , 2* np . pi , N )
58 I_m = max ( I ( d_Michelson ( R ) , l_r )) # = 4 I_o
59 r = R [0] # Valeur initiale de r
60 dr = R [2] - R [1]
61 while r <= max ( R ):
62 x = r * np . cos ( theta )
63 y = r * np . sin ( theta )
ELKIHEL

64 # plt . xlim (1.1* min ( x ) , 1.1* max ( x ))

65 # plt . ylim (1.1* min ( y ) , 1.1* max ( y ))
66 plt . plot (x ,y , color =( I ( d_Michelson ( r ) , l_r )/ I_m , I ( d_Michelson ( r ) , l_r )/ I_m ,0))
67 # on trace des cercles color é s en fonction de I ( r )/ I_m
68 plt . title ( " Michelson : franges d ’ interf é rence " )
69 r += dr
70 plt . savefig ( ’ interferences . pdf ’)
71 plt . show ()

Source monochromatique Source polychromatique Michelson : franges d'interférence

0.04
2.00 2.00
0.03
1.75 1.75

1.50 1.50 0.02

1.25 1.25 0.01

1.00 1.00 0.00

0.75 0.75 0.01

0.50 0.50 0.02

CPGE-MOHAMMEDIA

0.25 0.25
0.03
0.00 0.00
0.04
0.004 0.002 0.000 0.002 0.004 0.004 0.002 0.000 0.002 0.004 0.03 0.02 0.01 0.00 0.01 0.02 0.03
fig-15 :
figures d’interferences

32