Turbulent flow in a pipe

Sergio de Campos Junior

Algorithmics for Engineering Modeling

Master of Marine Technology: Hydrodynamics for Ocean Engineering (M-TECH HOE)

Introduction

The study of different flow regimes in pipelines is fundamental to understanding the behaviour of the velocity profile as a result of fluid transport. Predicting this profile makes it possible to understand the interaction of the flow with the pipeline and provide parameters, such as the mass flow rate, that make it possible to design the transport system—the power required for pumping and the thickness of the pipeline, for example. However, obtaining the velocity profile as a function of the pipeline radius requires understanding the flow regime—laminar, transient or turbulent—with which one expects to deal. Once the context is defined, it is possible to use the appropriate equation to estimate the velocity profile in the duct; this estimate, if compared with experimental data from an analogous regime, is inevitably subject to non-adherence.

This work aims to validate or not an estimate for the velocity profile in a duct whose turbulent flow is known experimentally. This estimate will be developed based on linear regressions made from a previously provided database containing data on the velocity profile collected in laboratory tests. The estimation itself comes from applying parameters to the equation that best describes the flow; these parameters, in turn, come from the interpolation prepared based on the regressions.

Finally, it is expected with this work to understand the importance of validating estimates with experimental data and practising computational techniques—such as linear regression, polynomial interpolation, and database parsing—viewed during classes, especially during the practical sessions.

Description of the problem

As exposed in the proposed problem statement, it is intended in this section to make clear the parameters and variables sufficient for the problem description. As already mentioned, turbulent flow is characterized by presenting chaotic behaviour, which implies the rapid variation of pressure and velocity in the field defined by the flow. A high Reynolds number characterizes such a chaotic regime—vide equation below—in this case, the instabilities are related to interactions between viscous terms and nonlinear inertial terms in the linear momentum equations.

Objective and procedure

the desired data is imported from the 6 ".txt" files, which are the databases;

address the data to their respective appropriate formats in the algorithm;

transform the velocity profile function (u(r) to u(y));

linearize the transformed function u(y);

modify the columns of the matrices containing the velocity and position in the duct cross-section so that they are in accordance with the linearized expression obtained in the previous step;

perform linear regression to find the straight line that best represents the data dispersion;

both the linear and angular coefficients of this straight line are determined; each must provide the parameters n and the maximum velocity Umax;

we perform the polynomial interpolation with the Lagrange method to obtain the polynomial that characterizes both functions n(Re) and Umax(Re);

we estimate n and Umax for Re = 35061 and determine the corresponding velocity profile through the equation u(y); and

the estimated data are compared with the experimental data through the percentage error, and the validation is concluded.

The following section explains the code implemented in Python 3.9 according to the described procedure and provides some considerations for running it in the Deepnote environment.

Implementation of the algorithm routine

The algorithm implementation considered what was presented during the practical sessions taught in the academic semester, from how to create functions in Python to how to perform linear regression and polynomial interpolation. Therefore, to obtain the expected results, it can be stated that all the techniques taught was somehow undertaken for the algorithm to be written—some attention will be given to the algorithm that performs linear regression and interpolation since it is understood that both are fundamental within the scope of this course.

The script is organized as follows:

firstly, the libraries understood to be essential for the algorithm to be appropriately executed by the compiler are imported. They are: re ("regular expression", package to help search and return expressions when reading imported files), math, NumPy and matplotlib.puplot;

next, the functions invoked as the compiler processes the script are defined. These are:

FindValue(fullstring), which receives a line in "str" format and returns the parameter values present in the header of the ".txt" file;

Read(filepath), which reads a ". txt" file and returns all the parameters of interest addressed correctly in their formats;

Linearization(DATA, R), which receives the matrix containing the velocity profile and the radius and returns this same matrix with values corrected by the linearization—already described in the previous section;

Linear_Regression(DATA, Re, R), which receives the matrix with the corrected velocity profiles and runs the linear regression, returning the linear and angular coefficients;

Interpolation(Ng, Ns, xi, fi, x), which in possession of its parameters performs the interpolation according to the Lagrange method and returns a list that represents the determined polynomial;

Error (u_exp, u_est), which in possession of both lists containing the experimental velocity and the estimated velocity, returns the percentual Error of both; and

the main() function, which has no parameters, invokes the other functions to execute the algorithm in an orderly fashion and is invoked at the end of the script.

The following subsections further detail the algorithms used to perform linear regression and interpolation according to methods seen during the practical sessions.

Linear Regression

Polynomial Interpolation: Lagrange method

The code: instructions and considerations

Since one is in Deepnote's environment, to execute the code, one needs to run the whole notebook or just the block that contains all the script—we chose in this work to keep the code agglutinated in a single executable block. If the script is executed in a compiler other than Deepnote, the argument of the Read(filepath) function, which is invoked right at the beginning of the main() function, must be modified since the files directory in another compiler will probably be different.

Considering this observation, all steps described in the section "Objective and procedure" should be executed, and all results should be "printed" on the screen so that it will be possible to validate or not the adherence of the estimated and experimental data—it is worth mentioning that the code is commented, which should facilitate its evaluation.

import re import math import numpy as np import matplotlib.pyplot as plt def FindValue(fullstring): # Function that finds parameter values in the database header. delimeter = '=' value = fullstring[fullstring.index(delimeter)+1:] value = value.replace(" ","") value = value.replace("m/s","") value = value.replace("m^2/s","") value = value.replace("m","") return value def Read(filepath): # Function that reads the file ".txt" and returns parameters. DATA = [] file = open(filepath, 'r') lines = file.readlines() file.close() i = 0 for line in lines: line = line.strip() if line.startswith('Re_tau ='): Re_tau = float(FindValue(line)) elif line.startswith('U_tau ='): U_tau = float(FindValue(line)) elif line.startswith('nu ='): nu = float(FindValue(line)) elif line.startswith('R ='): R = float(FindValue(line)) if i >= 6: DATA.append(re.findall(r'\d+\.\d+', line)) i +=1 for lin in range(len(DATA)): for col in range(len(DATA[0])): DATA[lin][col] = float(DATA[lin][col]) return Re_tau, U_tau, nu, R, np.array(DATA) def Linearization(DATA, R): # Function that receives a matrix with the nonlinear function u(r) and returns linearization F(Y). aux = np.copy(DATA) for i in range(len(aux)): aux[i][0] = math.log(DATA[i][0]/R) aux[i][1] = math.log(DATA[i][1]) return aux def Linear_Regression(DATA, Re, R): # Function that performs linear regression for the data. Y = Linearization(DATA, R)[:,0] F_Y = Linearization(DATA, R)[:,1] V = np.zeros((len(Y),2)) # Vandermonde matrix for i in range(len(Y)): for j in range(2): V[i,j] = Y[i]**j coefs = np.linalg.solve((V.transpose()).dot(V),(V.transpose()).dot(F_Y)) print("\n"," Coefficients of the linearized equation for Re = {}".format(Re),":") print("\n"," A = 1/n = ", np.round(coefs[1],3), "and", "B = ln(U_max) = ", np.round(coefs[0],3)) x = np.linspace(min(Y),max(Y),1000) # x axis for plotting f_x = coefs[1]*x + coefs[0] fig, ax = plt.subplots() ax.plot(Y, F_Y,'ok', label='Linearized Experiment Data') ax.plot(x, f_x,'r', label='Linear Regression') plt.xlabel("Y = ln(y/R)") plt.ylabel("F(Y) = ln[u(y)]") plt.grid(True) plt.title("Linearization and regression for Re = {}".format(Re)) ax.legend(); plt.show() return 1/coefs[1], math.e**coefs[0] def Interpolation(Ng, Ns, xi, fi, x): # Function that executes Lagrange Interpolation a_l = fi p_l = np.zeros_like(x) for i in range(Ng): for j in range(Ns): Lp_j = 1. # Initialize Lagrange Polynomial for k in range(Ns): if j is not k: Lp_j *= (x[i]-xi[k])/(xi[j]-xi[k]) p_l[i] += a_l[j]*Lp_j return p_l def Error(u_exp, u_est): # Function that calculates the error between both the experimental and estimated lists. num = 0 den = 0 for k in range(len(u_exp)): num += abs(u_est[k] - u_exp[k]) den += abs(u_exp[k]) return 100*(num/den) def main(): # Main function that runs the algorithm and invokes the other functions. Re_tau_5k, U_tau_5k, nu_5k, R, DATA_5k = Read("/work/Files_for_Flow/Data/Retau_5k_basic_stats.txt") Re_tau_10k, U_tau_10k, nu_10k, R, DATA_10k = Read("/work/Files_for_Flow/Data/Retau_10k_basic_stats.txt") Re_tau_20k, U_tau_20k, nu_20k, R, DATA_20k = Read("/work/Files_for_Flow/Data/Retau_20k_basic_stats.txt") Re_tau_30k, U_tau_30k, nu_30k, R, DATA_30k = Read("/work/Files_for_Flow/Data/Retau_30k_basic_stats.txt") Re_tau_35k, U_tau_35k, nu_35k, R, DATA_35k = Read("/work/Files_for_Flow/Data/Retau_35k_basic_stats.txt") Re_tau_40k, U_tau_40k, nu_40k, R, DATA_40k = Read("/work/Files_for_Flow/Data/Retau_40k_basic_stats.txt") n_5k, U_max_5k = Linear_Regression(DATA_5k, Re_tau_5k, R) n_10k, U_max_10k = Linear_Regression(DATA_10k, Re_tau_10k, R) n_20k, U_max_20k = Linear_Regression(DATA_20k, Re_tau_20k, R) n_30k, U_max_30k = Linear_Regression(DATA_30k, Re_tau_30k, R) n_40k, U_max_40k = Linear_Regression(DATA_40k, Re_tau_40k, R) Estimated = np.array([[Re_tau_5k, n_5k, U_max_5k], [Re_tau_10k, n_10k, U_max_10k], [Re_tau_20k, n_20k, U_max_20k], [Re_tau_30k, n_30k, U_max_30k], [Re_tau_40k, n_40k, U_max_40k]]) print("\n", "Estimated values of n [adm] and U_max [m/s]:", "", " | n |U_max|", np.round(Estimated[:,1:], 2), sep="\n") Ns = len(Estimated) Ng = 1000 Re = Estimated[:,0] ni = Estimated[:,1] Ui = Estimated[:,2] x = np.linspace(min(Re), max(Re), num=Ng) n = Interpolation(Ng, Ns, Re, ni, x) U_max = Interpolation(Ng, Ns, Re, Ui, x) fig, ax = plt.subplots() ax.plot(Re, ni,'xk', label='Data') ax.plot(x, n, '--g', label='Lagrange') plt.xlabel("Re [adm]") plt.ylabel("n") plt.grid(True) plt.title("Lagrange Interpolation: n(Re)") ax.legend(); plt.show() fig, ax = plt.subplots() ax.plot(Re, Ui,'xk', label='Data') ax.plot(x, U_max, '--g', label='Lagrange') plt.xlabel("Re [adm]") plt.ylabel("U_max [m/s]") plt.grid(True) plt.title("Lagrange Interpolation: U_max(Re)") ax.legend(); plt.show() print("\n", "With interpolation, we estimate for Re = 35061, U_max = 41.22128 m/s and n = 6.83221") # Calculating the velocity profile based on the estimate: n_35k = 6.83221 # [adm] U_max_35k = 41.22128 # [m/s] u_35k = [] for i in range(len(DATA_35k)): u_35k.append( U_max_35k * ((DATA_35k[:,0][i] / R)**(1/n_35k)) ) fig, ax = plt.subplots() ax.plot(u_35k, DATA_35k[:,0],'-', color='b', label='Estimated Speed Profile') ax.plot(DATA_35k[:,1], DATA_35k[:,0],'o', color='r', label='Experimental Speed Profile') plt.xlabel("u [m/s]") plt.ylabel("y [m]") plt.grid(True) plt.title("Speed Profile (Re = 35061)") ax.legend(); plt.show() clean_DATA_35k = DATA_35k[:,1].tolist() del clean_DATA_35k[0:3] del u_35k[0:3] print("\n", "The error found between the experimental velocity profile and the estimated one for Re = 35061 is: ", np.round(Error(clean_DATA_35k,u_35k), 3), "%") main()

The code above should print all the steps already mentioned on the screen. If the present file in ".pdf" format prevents the complete visualisation of the results, they can be found in the following section: "Results and conclusion".

Results and Conclusion

Bibliographic References

BERNHARD. Fluid dynamics - Reynolds number and inertial force - Physics Stack Exchange. 2013. Available at: <https://physics.stackexchange.com/questions/80070/ reynolds-number-and-inertial-force>.

SIMSCALE. What is Reynolds Number? | SimWiki | SimScale. 2021. Available at: <https: //www.simscale.com/docs/simwiki/numerics-background/what-is-the-reynolds-number/>.

AJAYAKUMAR, V. Parsing text with Python · vipinajayakumar. 2018. Available at: <https://www.vipinajayakumar.com/parsing-text-with-python/>.

.css-15w88e5{color:var(--chakra-colors-fg-neutral-primary);font-weight:inherit;letter-spacing:-0.09px;}Turbulent flow in a pipe