PROJET : APPLICATION AU CALCUL DE PERTE DE CHARGE

Nom : Zigui
Prénom : Evan Jean-Christ
Classe : Licence 3 ME-GT
Groupe : TD2

Introduction

On appelle perte de charge, la chute de pression due aux frottements divers contre les parois d’un tube
ou d’une gaine. En résulte une dissipation de l’énergie mécanique du fluide. Il existe deux types de
pertes de charge : les pertes linéaires et les pertes singulières. L’objectif de ce compte rendu est de
déterminer les vitesses de sortie 𝑣! et 𝑣" via l’expression de Bernoulli en se basant sur des programmes
algorithme sous Python.

Données

On retrouve les données du problème dans le tableau ci-dessous :

Pr Pa D L1 Lt r µ
4 bar 1bar 0,01m 1m 10m 1000𝑘𝑔. 𝑚#$ 10#$ 𝑘𝑔. 𝑚#" . 𝑠 #"

𝑣&'
∆𝐻%& = 𝐾%& 𝑜𝑢 𝐾%& 𝑒𝑠𝑡 𝑑é𝑓𝑖𝑛𝑖 𝑐𝑖 − 𝑑𝑒𝑠𝑠𝑜𝑢𝑠 (𝑇é)
2𝑔
𝑣&'
∆𝐻(& = 𝐾 𝑜𝑢 𝐾 𝑒𝑠𝑡 𝑑é𝑓𝑖𝑛𝑖 𝑐𝑖 − 𝑑𝑒𝑠𝑠𝑜𝑢𝑠 (𝑐𝑜𝑢𝑑𝑒)
2𝑔
𝑣&'
∆𝐻)& = x)& 𝑜𝑢 x)& 𝑒𝑠𝑡 𝑑é𝑓𝑖𝑛𝑖 𝑐𝑖 − 𝑑𝑒𝑠𝑠𝑜𝑢𝑠 (𝑣𝑎𝑛𝑛𝑒)
xx2𝑔

1) Relation de colebrook

La formule de Colebrook permet de calculer le coefficient lambda de pertes de charges linaires dues aux
frottements et à la viscosité. Suivant cette formule, on voit que le coefficient lambda dépend à la fois de
la rugosité de la conduite et de la viscosité du fluide.
Dans cette partie, nous allons créer une fonction lamb(v) en vérifiant que :
" ',."
𝑔(𝑥, 𝑅* ) = + 2𝑙𝑜𝑔"! C/ D
√, ! √,

Avec l vérifie g(l,Re) = 0 pour un nombre de Reynold donné.

On utilise la commande fsolve du package scipy.optimize sous la forme fsolve(f,𝒙𝟎 ) où x est une valeur
de départ pour l’algorithme et f la fonction dont on cherche une racine.

• On importe le module numpy pour n’importe quelle fonction, pour débuter le programme. Elle
définit la structure de tableau, il s’agit de données recueillies par ensembles et identifiées par une
séries d’indices.
• SciPy Optimize fournit des fonctions de minimisation de fonctions cibles, qui peuvent etre
contraintes. Il est composé des solveurs pour les problèmes non linéaires.

import numpy as np #on importe directement le module dans l’espace de noms

from scipy.optimize import fsolve

def lamb(Reynolds):
def f3(x,Re): #on définit la fonction
return 1/np.sqrt(x) + 2*np.log10(2.51/Re/np.sqrt(x)) #on pose la fonction
xinit = 0.3164*Reynolds**(-1/4) # point de départ de la recherche de zéro
sol = fsolve(f3,xinit,args=(Reynolds,)) # Reynolds est mis dans Re

return sol[0]

2) Traitement du cas avec une seule sortie

Nous allons remplacer le té par un coude, qui se traduira par la formule de Bernoulli suivante :

r𝑣!'
𝑃/ = 𝑃1 + + ∆𝑃23 + ∆𝑃(
2
2 r5 $
Avec ∆𝑃23 = l(𝑣! ) 4" '# où l(𝑣! ) est déterminé à l’aide de la fonction créée précédemment et ∆𝑃6 =
r5 $
𝐾 '# avec K=1,13.
On visualise le module suivant qui correspond pour que la relation de bernoulli soit vérifié :

def f(v): #on définit la fontion

rey = rho * v * d /mu #On ecrit Reynold
resultat = pa - pr + 0.5*rho*v**2*(1 + lamb(rey)*lt/d + kc) #la fonction rempalcer avec coude
return resultat
 3) Coefficient de perte de charge au niveau du tes

Pour connaitre les coefficients de pertes de charge nous allons utiliser la méthode d’interpolation.
L'interpolation est l'insertion d'une valeur ou d'un terme intermédiaire dans une série en l'estimant ou en
le calculant à partir de valeurs connues environnantes. C’est-à-dire l'insertion de quelque chose d'une
nature différente dans quelque chose d'autre.

SciPy nous fournit un module appelé scipy.interpolate qui a de nombreuses fonctions pour gérer
l’interpolation, ce sous-package contient des classes et des fonctions spline, des couches d’interpolation
1-D et multidimensionnelles (uni variées univariées et multidimensionnelles) ainsi que des
interpolateurs polynomiaux.

Pour cette partie, nous allons importer une bibliothèque graphique nommée matplotlib qui va nous
permettre d'afficher des graphiques :

from scipy.interpolate import interp1d

hsd = np.array([0,0.1,0.125,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1]) #tableau des valeurs de h/D

xi = np.array([10000,10000,97.8, 35, 10, 4.6,2.06,0.98,0.44,0.17,0.06,0])
xif = interp1d(hsd,xi)

Dans l'étape précédente, nous avons défini la position des moteurs à l'aide de position successives :

#creation de deux fonctions pour le coefficient de perte de charge

v0svt = np.array([0,0.2,0.4,0.6,0.8,1])
Kt1 = np.array([0.4,0.26,0.15,0.06,0.02,0])
Kt0 = np.array([1,1.01,1.05,1.15,1.32,1.45])
kt1f = interp1d(v0svt,Kt1)
kt0f = interp1d(v0svt,Kt0)
Fonction à annuler pour que la relation de Bernoulli soit vérifiée
# sur une sortie avec une vanne, la hauteur/D de la vanne est en paramètre de la fonction
def f1sortie_vanne(v, hv):
reynolds = rho * v * D / mu
return Pa - Pr + 0.5*rho*v**2*(1 +xif(hv) + lamb(reynolds)*Lt/D +K)

• Les tableaux « numpy » sont définis via des séquences Python telles que des listes et des tuples.
Les listes et les tuples sont caractérisé par [...] et (...).

• En utilisant la fonction interp1d, nous avons créé deux fonctions kt1f et kt1f. Ces fonctions, pour
une entrée donnée x retourne y.
 4) Mise sous forme d’un système non-linéaire

On cherche à déterminer les vitesses de sortie v0 et v1. Mettre les deux relations de bernoulli sous la
forme d’un système non-linéaire où les vitesses de sortie seront les solutions. Pour avancer pas à pas,
n’hésiter pas à tester votre programme sans perte de charge, ensuite avec les linéiques, et enfin avec les
singulières.

Pour initialiser la recherche de zéro, on prend le résultat, des vitesses de sortie sans perte de charge.

# Fonction à annuler pour que la relation de Bernoulli soit vérifiée

# pour les deux sorties
def ber2(v):
vt = v[0] + v[1]
rap = v[0] / vt
ret = rho * vt * D/mu; re1 = rho * v[1] * D /mu
dplt = 0.5*vt**2*rho*lamb(ret)*Lt/D
dpt0 = 0.5*vt**2*rho*kt0f(rap)
dpt1 = 0.5*vt**2*rho*kt1f(rap)
f0 = Pa-Pr + 0.5*rho*v[0]**2 + dplt + dpt0
f1• = Pa-Pr + 0.5*rho*v[1]**2*(1+K+lamb(re1)*L/D) + dplt + dpt1
return [f0, f1]

vinit = np.sqrt(2/rho*(Pr - Pa))

vsortie = fsolve(f1sortie,vinit)
print("vitesse pour une sortie :", vsortie)
vinit = np.sqrt(2/rho*(Pr - Pa))
vsortie = fsolve(f1sortie_vanne,vinit, args = (0.29,))

print("vitesse pour une sortie :", vsortie, "en imposant un hauteur de vanne")
vinit = np.array([20,20])
vsortie = fsolve(ber2,vinit)

print("vitesses pour deux sorties :", vsortie)

• Lorsque qu’on définit la méthode de classe, on explicite « init » comme premier argument de
chaque méthode. La fonction « init » est affecté après la création d’une instance de la classe est
créée. Elle se comporte comme un constructeur et peut prendre n'importe quel nombre
d'arguments et tout comme pour les fonctions, les arguments peuvent être définis avec des
valeurs par défaut, ce qui les rend facultatifs.

On observe deux solutions d’où deux vitesse lors de l’affichage sur spyder qui sont lors de
[1.41421356 -0.70710678] d’où V1 = 1,41m/s et V2 = -0,07 m/s.
 Conclusion

Au terme de notre analyse, nous avons puis mettre les équations données sous forme d’un
système linéaire à travers des algorithmes propres et spécifiques et aussi déterminer les deux
vitesses de sortie sans vanne.
La perte de charge linéaire est principalement due au fait que la viscosité du fluide aura
tendance à "coller" à la paroi des conduites et canalisations, le fluide est ralenti dans son
mouvement, puis s'écoule de façon turbulente. Afin de limiter au maximum la perte de
charge, le réseau de canalisations doit être limité au maximum ou supprimé localement. Pour
ce faire, il existe différentes possibilités comme éviter la longueur du conduit en utilisant des
trous pour laisser passer l'air, ne pas utiliser l'unité de ventilation en plaçant une unité
d'extraction séparée, augmentez le débit d'air sans augmenter la chute de pression en utilisant
des évents pour l'alimentation en air.