04. Modèle de l'écoulement parfait

PPT : Modele ecoulement parfait (761.66 Ko)

CODE :

In [1]:

# Importation des modules
import numpy as np
import numpy.random as npr
import matplotlib.pyplot as plt
import pandas as pd
from scipy.optimize import curve_fit,leastsq
#%matplotlib qt

In [2]:

# Definition de la fonction affine
def f_aff(x, a, b):
    return a*x+b

# Montecarlo
def montecarlo(X, Y, uX, uY, N_mc=100, color1='r', color2='b', mini=None, maxi=None):
    
    sigma_X = uX*np.ones(X.size)
    sigma_Y = uY*np.ones(Y.size)

    param = np.zeros((2,N_mc))
    for i in range(N_mc):
        x_mc = npr.normal(loc=X, scale=sigma_X)
        y_mc = npr.normal(loc=Y, scale=sigma_Y)
        pop, pcov = curve_fit(f_aff, x_mc, y_mc)
        param[0,i] = pop[0]
        param[1,i] = pop[1]
        
    mini = mini if mini else X.min()
    maxi = maxi if maxi else X.max()
    x_th = np.linspace(mini, maxi, 4)
    y_th = f_aff(x_th, *pop)
    for i in range(N_mc):
        y_th = f_aff(x_th, *param[:,i])
        #plt.plot(x_th, y_th, color2, alpha=0.05)  #ligne à décommenter si on veut afficher les 100 droites
    plt.errorbar(X, Y, xerr=uX, yerr=uY, fmt='+', capsize=2, color=color1,label="Mesures")
    # plt.show()

    a_moy = np.mean(param[0,:])
    b_moy = np.mean(param[1,:])
    x = np.linspace(0.8*min(X),max(X)*1.1,100)
    plt.plot(x,f_aff(x,a_moy,b_moy),'b--',label='Ajustement')

    #print("La pente moyenne sur les ", N_mc, "mesures est de :", np.round(a_moy,4))
    a_sig = np.std(param[0,:]) #ecart type
    b_sig = np.std(param[1,:]) #ecart type
    #print("L'écart type entre les pentes des", N_mc, "mesures est de :", np.round(a_sig,4))
    #print("Le résultat est donc de :", f"a = {a_moy:.3f} +/- {a_sig:.3f}")
    #print("Cela correspond à une erreur de:", f"a_rel = {a_sig/a_moy*100:.0f} %")
    return (a_moy, a_sig, b_moy, b_sig)

In [3]:

# Données 
rho = 1000 # Masse volumique de l'eau [kg/m^3]

d = 
ud = 
r = d/2
s = np.pi*r**2 # Section de sortie [m^2]
us = s*(ud/d)
etha = 1e-3

# Dataframe avec données
df = pd.read_csv("Torricelli.csv",  sep='\t', decimal=',',header=0)

# Données de la mesure prise en direct
ht =
m1 = 
m2 = 
t = 

df.loc[len(df)] = [ht,m1,m2,t]

df['h [m]'] = [df['h [cm]'][i]*1e-2 for i in df.index]
df['dm [kg]'] = [(df['mf [g]'][i] - df['mi [g]'][i])*1e-3 for i in df.index] # calcul de la masse d'eau écoulée
df['Qm [kg/s]'] = [df['dm [kg]'][i]/(df['dt [s]'][i]) for i in df.index] # débit massique 
df['vB [m/s]'] = [df['Qm [kg/s]'][i] / (rho * s) for i in df.index] # calcul de vb
df['vB² [m²/s²]'] = [df['vB [m/s]'][i]**2 for i in df.index]
#df['Re'] = [rho*d*df['vB [m/s]'][i]/etha for i in df.index]

#Incertitudes
uh = 
um = 
ut = 

df['uQm [kg/s]'] = [df['Qm [kg/s]'][i]*np.sqrt((um/df['dt [s]'][i])**2 + (-ut*df['dm [kg]'][i]/(df['dt [s]'][i]**2))**2) for i in df.index]
df['uvB [m/s]'] = [df['vB [m/s]'][i]*np.sqrt((df['uQm [kg/s]'][i]/(rho*s))**2 + (-us*df['Qm [kg/s]'][i]/(rho*s**2))**2) for i in df.index]
df['uvB² [m²/s²]'] = [df['vB² [m²/s²]'][i]*np.sqrt(2)*df['uvB [m/s]'][i]/df['vB [m/s]'][i] for i in df.index]

print(df) # affichage du dataframe (tableau)

In [4]:

# Tracé et récupération de a_moy et a_sig
a_moy, a_sig, b_moy, b_sig = montecarlo(df['h [m]'], df['vB² [m²/s²]'], uh , df['uvB² [m²/s²]'], color1='red', color2='blue')
plt.plot(df['h [m]'][len(df)-1], df['vB² [m²/s²]'][len(df)-1],'og', markersize = 10) # mesure prise en direct
plt.xlabel('h [m]')
plt.ylabel('vB² [m²/s²]')
plt.show()

In [5]:

g = a_moy/2 # ordre de grandeur de g mais désaccord avec quantitaif avec valeur attendue lié à la contraction de la section du fluide (cf fruchard)
print('g = ',round(g,2),'+/-',round(a_sig/2,2),'m/s²')
print(b_moy, b_sig)

In [6]:

# Prise en compte surface lié à la pression imposée par tube plongé dans le vase de mariotte
D = #diametre du tube plongé dans le vase
S = np.pi*D/4

g = a_moy*(1-(s/S))/2
print(g)

Temps de vidange¶

In [7]:

g = 9.81
d_ = # diamètre du trou

S = # surface de la boite
uS = 

s = np.pi*(d_/2)**2
us = 1e-3**2

H = # hauteur d'eau correspondant au temps de vidange considéré
uH = 

t = np.sqrt(2*H/g)*S/s
ut = t * np.sqrt((uS/S)**2 + (uH/H)**2 + (us/s)**2)

print("Le temps de vidange thérorique est de",np.round(t/60,1),"+/-",np.round(ut/60,1),"min.")

Le temps de vidange thérorique est de +/-  min.

In [ ]:

Date de dernière mise à jour : 06/06/2025