4. Analyse de champ

Marc BUFFAT, dpt mécanique, Université Claude Bernard Lyon 1

Mise à disposition selon les termes de la Licence Creative Commons
.

%matplotlib inline
%autosave 300
import numpy as np
import scipy as sp
import matplotlib.pyplot as plt
from IPython.core.display import HTML
from matplotlib import animation
from cinematique import part_animation

Autosaving every 300 seconds

4.1. Analyse locale d’un champ

Etude locale de la trajectoire d’une particule fluide dans un champ de vitesse \(U\) dont on se donne le gradient: \(\mathbf{grad}\,U\)

• Localement le champ de vitesse en \(X_0+dX\) est:

\[ u = u_0 + \frac{\partial u}{\partial x} dx + \frac{\partial u}{\partial y} dy\]

\[ v = v_0 + \frac{\partial v}{\partial x} dx + \frac{\partial v}{\partial y} dy\]

\[ \vec{U} = \vec{U}_0 + \mathbf{grad}\,\vec{U} \times d\vec{X} \]

• Les trajectoires des particules fluides \(\vec{M}(t)=\vec{M}_0(0)+d\vec{M}\) vérifient:

\[ \frac{d \vec{M}}{dt} = \vec{U}(M) = \vec{U}_0 + \mathbf{grad}\,\vec{U} \times d\vec{M}\]

• la rotation solide d’une particule (ex: \(U_\theta = \omega r\))

\[ \vec{\Omega} = \frac{1}{2} \mathbf{rot}\,\vec{U}\]

• Le volume d’une particule varie comme la divergence du champ de vitesse \(div\,\vec{U}\)

\[ \frac{1}{V}\frac{dV}{dt} \equiv div\,\vec{U} = trace(\mathbf{grad}\,\vec{U}) \]

4.2. Analyse locale d’un champ 2D

On se donne la valeur locale \(U_0\) et son gradient \(\mathbf{grad} U\) du champ de la vitesse.

Locallement en supposant que ce gradient est constant on peut écrire

\[\begin{split} \vec{U}(x,y) = \vec{U}_0 + \mathbf{grad}\, \vec{U} \times \begin{bmatrix} x-x_0 \\ y-y_0 \end{bmatrix}\end{split}\]

4.2.1. Champ incompressible

\[div \, \vec{U} = 0\]

donc $\( trace(\mathbf{grad} \vec{U}) = 0\)$

U0=np.array([1.0,0.])
gradU=np.array([[-1,1.0],[1.,1.0]])
anim=part_animation(U0,gradU,FigSize=(7,5))

Gradient de U    = | -1 1 |
                   | 1 1 |
Divergence div(U)= 0.0
Rotation W_z     = 0.0
volume initiale  0.020000000000000004
Animation avec  40

plt.rc('animation', html='jshtml')
anim

Once Loop Reflect

4.2.2. Cisaillement homogéne

gradU=np.array([[0,1],[0,0]])
anim=part_animation(U0,gradU,FigSize=(7,5))

Gradient de U    = | 0 1 |
                   | 0 0 |
Divergence div(U)= 0
Rotation W_z     = -0.5
volume initiale  0.020000000000000004
Animation avec  40

plt.rc('animation', html='jshtml')
anim

Once Loop Reflect

4.2.3. Rotation homogéne

gradU=np.array([[0,1],[-1,0]])
anim=part_animation(U0,gradU,FigSize=(7,5))

Gradient de U    = | 0 1 |
                   | -1 0 |
Divergence div(U)= 0
Rotation W_z     = -1.0
volume initiale  0.020000000000000004
Animation avec  40

plt.rc('animation', html='jshtml')
anim

Once Loop Reflect

4.2.4. Déformation à volume constant

gradU=np.array([[1,0.5],[0.5,-1]])
anim=part_animation(U0,gradU,FigSize=(7,5))

Gradient de U    = | 1 0.5 |
                   | 0.5 -1 |
Divergence div(U)= 0.0
Rotation W_z     = 0.0
volume initiale  0.020000000000000004
Animation avec  40

plt.rc('animation', html='jshtml')
anim

Once Loop Reflect

4.2.5. Compression

gradU=np.array([[-1,0.],[0.,0.5]])
anim=part_animation(U0,gradU,FigSize=(7,5))

Gradient de U    = | -1 0 |
                   | 0 0.5 |
Divergence div(U)= -0.5
Rotation W_z     = 0.0
volume initiale  0.020000000000000004
Animation avec  40

plt.rc('animation', html='jshtml')
anim

Once Loop Reflect

4.2.6. Dilatation

gradU=np.array([[1,0.],[0.,-0.5]])
anim=part_animation(U0,gradU,FigSize=(7,5))

Gradient de U    = | 1 0 |
                   | 0 -0.5 |
Divergence div(U)= 0.5
Rotation W_z     = 0.0
volume initiale  0.020000000000000004
Animation avec  40

plt.rc('animation', html='jshtml')
anim

Once Loop Reflect

4.3. Cas Général d’un écoulement compressible

• décomposition du champ de vitesse

\[ \vec{U}(M) = \vec{U}(O) + (\nabla \vec{U})\times\vec{OM} \]

• en partie anti-symétrique (rotation) et symétrique (déformation)

\[ \vec{U}(M) = \vec{U}(O) + \vec{\Omega} \wedge \vec{OM} + D \]

gradU=np.array([np.random.rand(2),np.random.rand(2)])
anim=part_animation(U0,gradU,FigSize=(7,5))

Gradient de U    = | 0.71253 0.0855938 |
                   | 0.655131 0.813593 |
Divergence div(U)= 1.5261233723472865
Rotation W_z     = 0.2847686377847115
volume initiale  0.020000000000000004
Animation avec  40

plt.rc('animation', html='jshtml')
anim

Once Loop Reflect

4.3.1. partie déformation (symétrique)

UZ = np.array([0.,0.])
D  = 0.5*(gradU + gradU.transpose())
anim=part_animation(U0,D,FigSize=(7,5))

Gradient de U    = | 0.71253 0.370362 |
                   | 0.370362 0.813593 |
Divergence div(U)= 1.5261233723472865
Rotation W_z     = 0.0
volume initiale  0.020000000000000004
Animation avec  40

plt.rc('animation', html='jshtml')
anim

Once Loop Reflect

4.3.2. partie rotation(antisymétrique)

R  = 0.5*(gradU - gradU.transpose())
anim=part_animation(U0,R,FigSize=(7,5))

Gradient de U    = | 0 -0.284769 |
                   | 0.284769 0 |
Divergence div(U)= 0.0
Rotation W_z     = 0.2847686377847115
volume initiale  0.020000000000000004
Animation avec  40

plt.rc('animation', html='jshtml')
anim

Once Loop Reflect

4.4. Cas Général d’un écoulement incompressible

gradU=np.array([np.random.rand(2),np.random.rand(2)])
gradU[1,1]=-gradU[0,0]
anim=part_animation(U0,gradU,FigSize=(7,5))

Gradient de U    = | 0.380812 0.312539 |
                   | 0.0840085 -0.380812 |
Divergence div(U)= 0.0
Rotation W_z     = -0.11426518464144875
volume initiale  0.020000000000000004
Animation avec  40

plt.rc('animation', html='jshtml')
anim

Once Loop Reflect

4.5. FIN