-- AER004: Mécanique des fluides appliquée --
TN n°3
Abaque numérique
simon.marie@lecnam.net
Pour ceux qui ne seraient pas familier avec le language python, vous pouvez consulter le Notebook Introduction au Python.
L'abaque de Moody-Moutine est utilisé pour déterminer graphiquement le coefficient de perte de charge linéaire λ en fonction du nombre de Reynolds. On peux alors envisager de définir une version numérique sous la forme d'une fonction qui renvoi la valeur de λ en fonction du Reynolds et éventuellement de la rugosité relative r.
Dans un premier temps, on va définir les fonctions associées aux principales formules des pertes de charges en régime turbulent :
import numpy as np
import matplotlib.pyplot as plt
import math
import copy
# Blasius (turbulent lisse):
def Blasius(Re):
l=0.316*Re**(-0.25)
return l
# Nikuradse simple (turbulent lisse):
def Nikuradse(Re):
l=0.0032+0.221*Re**(-0.0237)
return l
# IdelCik (turbulent lisse):
def IdelCik(Re):
l=1./((1.8*math.log10(Re)-1.64)**2)
return l
# Nikuradse implicite (turbulent lisse)
def K_Nikuradse(Re):
# On supose une valeur initiale pour l (par exemple Blasius):
l=Blasius(Re)
# On calcul la nouvelle valeur de l avec la formule de Nikuradse:
l2=1./(2*math.log10(Re*math.sqrt(l))-0.8)**2
i=0;
# On recommence tant que la difference entre les deux est plus grande que 0.0001
while abs(l2-l)>1e-4:
i+=1
l=l2.copy()
l2=1./(2*math.log10(Re*math.sqrt(l))-0.8)**2
return l2
# Collebrook implicite (Turbulent intermédiaire):
def Collebrook(Re,r):
l=Nikuradse(Re)
l2=1./(-2.*math.log10((2.51/(Re*math.sqrt(l)))+r*(1./3.71)))**2
i=0;
while abs(l2-l)>1e-4:
i+=1
l=l2
l2=1./(-2.*math.log10((2.51/(Re*math.sqrt(l)))+r*(1./3.71)))**2
return l2
# Nikuradse rugeux (turbulent rugueux):
def Nikuradse_Rug(r):
l=1./(1.14-2.*math.log10(r))**2
return l
Blasius(3000)
On peut donc calculer la valeur de λ en utilisant la bonne formule en fonction du nombre de Reynolds. Maintenant, on va faire une fonction qui choisira la bonne formule pour nous !
def lcoeff(Re,r=0):
#En spécifiant r=0 dans les argument de la fonction,
#on suppose que si la valeur de r n'est pas donnée par l'utilisateur, elle sera nulle par défaut.
if Re<2000: #Laminaire
l=64./Re
elif (Re>=2000 and Re<1e5 and r<=1e-5):
l=Blasius(Re)
elif (Re>=2000 and Re<1e5 and r>1e-5):
l=Collebrook(Re,r)
elif (Re>1e5 and r<=1e-5):
l=Collebrook(Re,r)
elif (Re>1e5 and r>1e-5):
l=Nikuradse_Rug(r)
return l
# Test:
print lcoeff(500)
print lcoeff(4000)
print lcoeff(10000,0.001)
print lcoeff(1e6,0.001)
La fonction lcoeff renvoie donc la bonne valeur du coefficient λ en choisissant la bonne formule a utiliser en fonction du nombre de Reynolds. On peut maintenant utiliser cette fonction pour calculer directement la perte de charge linéaire ΔP en fonction des grandeurs d'entrée U,L,D,ν,r:
def perte_lin(L,D,U,r=1e-6,rho=1000,nu=1e-6):
#Par defaut on a de l'eau (rho=1000 et nu=1e-6)
Re=U*D/nu
dP=lcoeff(Re,r)*(L/D)*0.5*rho*U**2
return dP
#Exemple: perte de charge dans un tuyau de 1cm de diamètre de 1m de long avec de l'eau à 1m/s de vitesse debitante:
print perte_lin(1.,0.01,1.) # Le résultat est en pascal
print perte_lin(1.,0.01,1.,nu=1e-5)
On peux également construire des fonctions qui utilisent le débit volumique qv et le débit massique qm plutôt que la vitesse débitante:
def perte_lin_qv(L,D,qv,r=1e-6,rho=1000,nu=1e-6):
#Par defaut on a de l'eau (rho=1000 et nu=1e-6)
#Calcul de la section que l'on suppose circulaire:
S=np.pi*D**2/4.
U=qv/S
Re=U*D/nu
dP=lcoeff(Re,r)*(L/D)*0.5*rho*U**2
return dP
def perte_lin_qm(L,D,qm,r=1e-6,rho=1000,nu=1e-6):
#Par defaut on a de l'eau (rho=1000 et nu=1e-6)
#Calcul de la section que l'on suppose circulaire:
S=np.pi*D**2/4.
qv=qm/rho
U=qv/S
Re=U*D/nu
dP=lcoeff(Re,r)*(L/D)*0.5*rho*U**2
return dP
#Exemple du pipeline du TD1:
print perte_lin_qm(5510.,0.25,18.,rho=900.,nu=0.261/900.)
print
Vous pouvez télécharger ce Notebook ici et l'éxecuter sur JupyterHUB
from IPython.core.display import HTML
style=open('notebooks.css', "r").read()
HTML(style)