-- 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 $\lambda$ 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 $\lambda$ 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 :

In [1]:
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
In [2]:
Blasius(3000)
Out[2]:
0.042697924891902286

On peut donc calculer la valeur de $\lambda$ en utilisant la bonne formule en fonction du nombre de Reynolds. Maintenant, on va faire une fonction qui choisira la bonne formule pour nous !

In [2]:
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)
0.128
0.039734896378
0.0323759935115
0.019615689413

La fonction lcoeff renvoie donc la bonne valeur du coefficient $\lambda$ 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 $\Delta P$ en fonction des grandeurs d'entrée $U,L,D,\nu,r$:

In [3]:
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)
1580.0
3200.0

On peux également construire des fonctions qui utilisent le débit volumique $q_v$ et le débit massique $q_m$ plutôt que la vitesse débitante:

In [4]:
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 
300000.628192

Vous pouvez télécharger ce Notebook ici et l'éxecuter sur JupyterHUB

In [1]:
from IPython.core.display import HTML
style=open('notebooks.css', "r").read()
HTML(style)
Out[1]: