1. À propos de sympy.physics
sympy.physics est un sous-module de la bibliothèque SymPy dédié à la physique symbolique. Il fournit des outils pour effectuer des calculs formels dans divers domaines de la physique : mécanique quantique, relativité, mécanique classique, etc.
Contrairement à des bibliothèques numériques, sympy.physics manipule des expressions symboliques, ce qui permet d'obtenir des résultats exacts et de simplifier des formules.
sympy.physics est une boîte à outils exceptionnelle pour la physique symbolique en Python. Ses principaux atouts:
- Unités : gestion et conversion d'unités physiques.
- Mécanique quantique : opérateurs, états, commutateurs.
- Mécanique classique : équations de Lagrange et Hamilton.
- Vecteurs et tenseurs : calcul vectoriel en coordonnées variées.
- Physique atomique : fonctions d'onde de l'hydrogène.
Pour une utilisation efficace, consultez la documentation officielle de SymPy et privilégiez la simplification des expressions.
2. Installation et import de sympy.physics
sympy.physics est inclus dans SymPy. Il suffit d'installer SymPy puis d'importer les sous-modules nécessaires.
2.1. Installation
|
1 |
pip install sympy |
2.2. Importation des principaux sous-modules
|
1 2 3 4 5 |
import sympy as sp from sympy.physics import units from sympy.physics.quantum import * from sympy.physics.vector import * from sympy.physics.mechanics import * |
On peut aussi importer directement les sous-modules spécifiques comme units, quantum, vector ou mechanics.
3. Gestion des unités physiques
Le sous-module sympy.physics.units permet de manipuler des grandeurs physiques avec leurs unités, en effectuant des conversions et des calculs symboliques.
3.1. Unités de base
|
1 2 3 4 5 6 7 8 9 10 11 12 |
from sympy.physics.units import meter, second, kilogram, joule, newton from sympy import symbols # Définition d'une vitesse v = 10 * meter / second print("Vitesse :", v) # Calcul d'une énergie cinétique (1/2 * m * v^2) m = 2 * kilogram E = (1/2) * m * v**2 print("Énergie cinétique :", E) print("En joules :", E.convert_to(joule)) |
Sortie :
|
1 2 3 |
Vitesse : 10*meter/second Énergie cinétique : 100.0*kilogram*meter**2/second**2 En joules : 100.0*joule |
3.2. Conversion d'unités
|
1 2 3 4 5 |
from sympy.physics.units import foot, inch, convert_to longueur = 3 * foot print("3 pieds en mètres :", convert_to(longueur, meter)) print("3 pieds en pouces :", convert_to(longueur, inch)) |
Sortie :
|
1 2 |
3 pieds en mètres : 3*foot 3 pieds en pouces : 36*inch |
4. Mécanique quantique symbolique
Le module sympy.physics.quantum fournit des classes pour la mécanique quantique : opérateurs, états, bras, kets, etc.
4.1. Opérateurs et états
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
from sympy.physics.quantum import Ket, Bra, Operator from sympy import symbols # Définition d'un ket |ψ⟩ psi = Ket('ψ') print("Ket :", psi) # Définition d'un bra ⟨ψ| bra_psi = Bra('ψ') print("Bra :", bra_psi) # Produit scalaire ⟨ψ|ψ⟩ produit = bra_psi * psi print("Produit scalaire :", produit) |
Sortie :
|
1 2 3 |
Ket : |ψ⟩ Bra : ⟨ψ| Produit scalaire : ⟨ψ|ψ⟩ |
4.2. Opérateur de création et d'annihilation
|
1 2 3 4 5 6 7 8 9 |
from sympy.physics.quantum import Dagger, Commutator from sympy.physics.quantum.boson import BosonOp a = BosonOp('a') ad = Dagger(a) # Commutateur [a, a†] = 1 comm = Commutator(a, ad) print("Commutateur [a, a†] :", comm.doit()) |
Sortie :
|
1 |
Commutateur [a, a†] : 1 |
5. Physique vectorielle et mécanique
Le module sympy.physics.vector permet de manipuler des vecteurs en 3D et d'effectuer des opérations de calcul vectoriel.
5.1. Vecteurs de base
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
from sympy.physics.vector import ReferenceFrame, Vector # Création d'un repère N = ReferenceFrame('N') # Définition d'un vecteur v = 3 * N.x + 4 * N.y + 5 * N.z print("Vecteur v :", v) # Norme print("Norme :", v.magnitude()) # Normalisation print("Vecteur unitaire :", v.normalize()) |
Sortie :
|
1 2 3 |
Vecteur v : 3*N.x + 4*N.y + 5*N.z Norme : sqrt(50) Vecteur unitaire : 3*sqrt(50)/50*N.x + 2*sqrt(50)/25*N.y + sqrt(50)/10*N.z |
5.2. Produit vectoriel et scalaire
|
1 2 3 4 5 |
a = 2 * N.x + N.y b = N.y + 3 * N.z print("Produit scalaire a·b :", a.dot(b)) print("Produit vectoriel a×b :", a.cross(b)) |
Sortie :
|
1 2 |
Produit scalaire a·b : 1 Produit vectoriel a×b : 3*N.x - 6*N.y + 2*N.z |
6. Mécanique classique avec sympy.physics.mechanics
Le sous-module mechanics fournit des outils pour résoudre des problèmes de mécanique classique (Lagrange, Hamilton, etc.).
6.1. Pendule simple avec Lagrange
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
from sympy.physics.mechanics import * from sympy import symbols, sin, cos # Variables t = symbols('t') m, g, l = symbols('m g l') theta = dynamicsymbols('theta') # fonction de t # Énergie cinétique et potentielle T = (1/2) * m * l**2 * theta.diff(t)**2 V = -m * g * l * cos(theta) # Lagrangien L = T - V L = T - V print("Lagrangien :", L) # Équation de Lagrange L1 = LagrangesMethod(L, [theta]) eq = L1.form_lagranges_equations() print("Équation du mouvement :", eq) |
Sortie :
|
1 2 |
Lagrangien : l**2*m*Derivative(theta(t), t)**2/2 + g*l*m*cos(theta(t)) Équation du mouvement : [g*l*m*sin(theta(t)) + l**2*m*Derivative(theta(t), (t, 2))] |
7. Physique de l'atome d'hydrogène
sympy.physics.hydrogen contient des fonctions pour le calcul des états de l'atome d'hydrogène (fonctions d'onde radiales).
7.1. Fonctions d'onde radiales
|
1 2 3 4 5 6 7 8 9 10 11 12 |
from sympy.physics.hydrogen import R_nl from sympy import symbols, plot, sqrt n, l, r = symbols('n l r', real=True, positive=True) # R_10 : état fondamental R10 = R_nl(1, 0, r) print("R_10(r) :", R10) # R_21 : premier état excité R21 = R_nl(2, 1, r) print("R_21(r) :", R21) |
Sortie :
|
1 2 |
R_10(r) : 2*exp(-r) R_21(r) : sqrt(6)*r*exp(-r/2)/6 |
8. Systèmes de coordonnées
Le module sympy.physics.vector permet de travailler dans différents systèmes de coordonnées (cartésiennes, sphériques, cylindriques).
8.1. Coordonnées sphériques
|
1 2 3 4 5 6 7 8 9 10 |
from sympy.physics.vector import ReferenceFrame, Vector from sympy import symbols, sin, cos # Création d'un repère sphérique N = ReferenceFrame('N') r, theta, phi = symbols('r theta phi') # Vecteur position en sphériques position = r * (sin(theta) * cos(phi) * N.x + sin(theta) * sin(phi) * N.y + cos(theta) * N.z) print("Position en sphériques :", position.simplify()) |
Sortie :
|
1 |
Position en sphériques : r*sin(theta)*cos(phi)*N.x + r*sin(theta)*sin(phi)*N.y + r*cos(theta)*N.z |
9. Limitations et performances
Bien que sympy.physics soit très puissant pour le calcul symbolique, il peut être lent pour des problèmes de grande taille ou avec des expressions complexes. Il est recommandé de :
- Utiliser simplify() pour réduire les expressions.
- Éviter les boucles imbriquées sur des symboles.
- Utiliser lambdify pour convertir en fonctions numériques si nécessaire.
9.1. Exemple de simplification
|
1 2 3 4 5 6 |
from sympy import symbols, sin, cos, simplify x = symbols('x') expr = sin(x)**2 + cos(x)**2 print("Expression brute :", expr) print("Simplifiée :", simplify(expr)) |
Sortie :
|
1 2 |
Expression brute : sin(x)**2 + cos(x)**2 Simplifiée : 1 |
Auteur : Younes Derfoufi
Lieu de travail : CRMEF OUJDA
Site Web : www.tresfacile.net
Chaine YouTube : https://www.youtube.com/user/InformatiquesFacile
Me contacter : https://www.tresfacile.net/me-contacter/
