Heat exchangers (HEs) are essential in process industries for eficient thermal energy transfer. Their design and optimization are crucial for improving energy eficiency, reducing costs, and ensuring reliable system performance. However, these tasks are complex due to varying fluid properties, phase changes, and fouling. This study proposes the HxLLM framework, utilizing Large Language Models (LLMs) to aid in the design and optimization of HEs. The framework identifies the mathematical model for heat transfer in HEs, followed by retrieval-augmented generation (RAG) based code generation and correction. In this study, a repository was created by extracting mathematical models from relevant literature along with common errors observed in such tasks. These repositories, combined with carefully crafted prompts, were used to extract the mathematical model and generate the corresponding code within this framework. We observed that LLMs can efectively identify and generate initial code for mathematical models, though first responses often needed corrections. The RAG approach for code correction significantly enhanced code accuracy. This study demonstrates that LLMs, with a RAG framework, can automate and improve the design and optimization process of HEs, ofering a promising tool for engineers and researchers to achieve better eficiency and cost-efectiveness.
2. Methodology
veyed ChatGPT-related research, highlighting LLM
applications in education, medicine, and physics, driven
by innovations in pre-training and fine-tuning. Kashefi Designing and optimizing a heat exchanger typically
inand Mukerji [
Inspired by these developments, this study explores design and optimization of heat exchangers. It has three the application of LLMs for automating the design and main components: mathematical model identification, optimization of heat exchangers with HxLLM framework. code retrieval for the mathematical model, and code genThe primary objective is to develop a system that can gen- eration and correction. In subsequent sections, we diserate mathematical models and optimization algorithms cuss the components of the HxLLM framework and how based on user-input, leveraging the capabilities of LLMs it utilizes the mathematical model repository and code to determine optimal parameter values and perform cost error repository. optimization. By extracting relevant information from research articles, LLMs could potentially generate mod- 2.1. Mathematical model identification els and propose optimized designs through an iterative, interactive process, reducing the manual efort required.
This component extracts the mathematical model from the user input. User input can also include a research article that the user might want to use for a new design.
Figure 1 (a) shows the mathematical model identification <paper> {raw_text} </paper> Please carefully read through the mathematical model section of the paper above. Identify and list all the unique equations that are used to construct the model.
For each equation you find: - Give it a specific, descriptive name based on what it represents or calculates. For example, if there is an equation for "tube side heat transfer coeficient", name it something like "Tube side heat transfer coeficient (ht)". - Briefly describe how to calculate the equation based on the information in the paper.
Avoid using generic labels like "Equation ()" for the names. Also avoid using phrases like "Calculated using equation ()" in your descriptions. Instead, just provide a general description of how each equation is calculated.
Output your final list of named and described equations inside <equations>tags.
The highest similarity score obtained with mathematical model extraction component, is then compared with threshold similarity score. In this case, if the similarity score is greater than 75%, the summary corresponding to the highest similarity score is extracted. Subsequently, we retrieve the code associated with that summary, which serves as our sample base code for further processing. The details of this step are illustrated in Fig. 1 (b). If the similarity score is less than 75%,then the paper is new and does not match any summary in our repository, and an alternative approach is employed. This approach pairs a most similar research article mathematical model with its corresponding code and, when presented with a new research article, uses a sequential prompting technique to produce the desired output.This essentially represents a few-shot prompting example, as illustrated in Fig. 2
The sample base code obtained from previous compocomponent. The user provides scientific text or a research nent, along with chain of thought prompting technique, article (in PDF file format), which is then processed by the enables the LLM to generate new code through sequenLLM. The LLM is prompted (see table 1 for the prompt tial prompting (see prompts in table 2 and table 3). In provided to the LLM) to summarize the mathematical this component, we created the error database for errors model described in the article, focusing solely on its de- that were encountered while creating the code for each scription instead of detailed equations. This approach mathematical model (see Fig. 1(c)). It contains a list of was chosen due to challenges with accurately parsing potential errors encountered in mathematical models for and reading equations (mathematical expressions present heat exchangers. Code generated by LLM is executed, in the article) using our current PyPDF reader for text and if the execution results in an error , then RAG based extraction from the research article PDF file. technique is used to get similar error and its resolution . Then again the prompt with similar error and its resolution is given to the LLM (see prompt in table 4 and table prompt 5). This iteration continues until specific number of times (in this case 3) or terminates early if the execution is successful. In case code exits with error then human provides the resolution of the error and then once again the code generation loop continues.
taining mathematical models from multiple papers to check for similarity. If a match is found, we retrieve the base code as a reference for the LLM to generate the mathematical model described in the paper. To ensure the accuracy of the generated code, we incorporate a code correction framework along with RAG techniques.
If the base code is not present, we use few-shot examples to generate the mathematical model and subsequently the optimization model.
In summary, HxLLM framework takes user input in the
form of research article PDF and generates the code for 3. Results and Discussion
mathematical model and optimization algorithm
mentioned in the research article. The entire workflow is In this study, we used the Anthropic Claude 3 Opus model
presented in Fig, 2. Initially, the workflow processes a as the LLM, and several research articles, including [
1–22
You will be optimizing the mathematical model of a heat exchanger based on provided code and an optimization algorithm from a research paper.
Here is the code for the heat exchanger model: <code> {Code} </code> And here is the paper having the optimization algorithm: <paper> {raw_text} </paper> Please carefully read through the code and paper to understand the heat exchanger model and the proposed optimization approach.
After reviewing the materials, please identify the target/design variables that the paper aims to optimize, along with any specified limits on those variables. List out each variable and its limits (if given).
Next, find the unified linking function described in the paper. Show how to incorporate this linking function into the optimization algorithm.
Then, write out the full code that performs the optimization of the heat exchanger model. Use the target/design variables, limits, and unified linking function you identified from the paper. Aim to closely follow the optimization approach from the paper while integrating it with the existing heat exchanger model code.
Before outputting the final code, take a moment to double check that your code follows the optimization algorithm correctly and that you have used the right variables and limits. Think through the optimization process step-by-step to verify the logic.
Finally, output the complete optimized code inside <optimized_code>tags. Also output the final optimized values of the target/design variables inside <optimized_values>tags.
Remember, the goal is to implement the paper’s optimization approach to find optimal values for the heat exchanger model’s design variables. Let me know if you have any other questions!
As mentioned before, it is expected that user will provide
the scientific text containing the mathematical model for
heat exchanger design. This text is passed as context
along with prompt (mentioned in table 1 to LLM for
extraction of the mathematical model and its parameters.
For this study, we have considered the research article
by [
Closest summary index: 11 Similarity score: 0.924 Closest summary: 1. Heat transfer area (A): Calculated using the heat transfer rate, overall heat transfer coeficient, LMTD correction factor, and logarithmic mean temperature diference. 2. Heat transfer rate (Q): Determined from an energy balance using the mass flow rates and specific heats of the hot and cold fluids along with their inlet and outlet temperatures. 3. Tube side flow velocity (Vi): Calculated from the tube side mass flow rate, fluid density, number of tubes, number of tube passes, and tube inner diameter. 4. Number of tubes (NT): Estimated using an empirical correlation based on the shell diameter, tube outer diameter, and coeficients that depend on the tube layout and number of passes. 5. Tube side Reynolds number (Re): Calculated from the tube side flow velocity, tube inner diameter, and kinematic viscosity of the tube side fluid.
...continued... the equations present within the original codebase that necessitate alterations. It details which segments in the base code should be modified to ensure the accuracy and logical integrity of extracted mathematical model. Following this, we provided the next prompt (Table:3), instructing the model to include these changes in the base code and rewrite it coherently. The generated code for this step is given in appendix 5.2.
To ensure that, the generated code is accurate and runs without any errors, this code was passed to the code correction framework. The errors encountered during the execution of the code, are presented in figure 3. Simple errors (not present in the error repository) was resolved by prompting (see table 4) LLM and errors which was not so obvious for LLM (listed in error repository) were resolved through RAG based approach with prompt (given in table 5). It may happen, though, that errors may still not be resolved; in that case, the error was resolved manually, and the solution for the error was added to the error repository for further reference by LLM.
By learning from past errors in this way, the RAG system can iteratively improve the quality and accuracy of the code it produces. The final result of the error-free mathematical code generated by the LLM is provided in (Appendix:5.2).
In the previous section 3.1, we described the steps for user input for which we had similar mathematical model. However, in practical scenario user may come up with models that may not be similar to model available in mathematical model repository. In such scenario, we adopted the diferent steps for code generation of mathematical models. These steps are described below:
We have selected the research article [34], for which similar mathematical model is not available in the model repository. The provided paper mainly discusses the application of Rao algorithms to optimize mechanical system component designs, assessing their comparative efectiveness against established methods in addressing complex constraints and mixed-type variables. However, our database contains papers focused on the cost optimization of heat exchangers. We use the prompt (given in table 1) to generate the mathematical model summary. LLM generated summary is given in table 11.
The mathematical model summary (in table 11) when compared using TF-IDF vectorizer based retriever, we found that, similarity index was 0.512, indicating that no mathematical model closely matches the generated mathematical model summary. Hence, the sample code was taken as reference base code for the step of code generation.
Since we are not using the base code which is similar to the mathematical model, in this case we ask the LLM to generate the code from scratch with sample code using few-shot example prompting approach (Table:12). We provided a closely matched reference paper, the mathematical model related to the paper, and associated it with the prompt in a way that the model learns from the example how to build the mathematical model for an optimization algorithm problem. The result generated with this approach is given in appendix 5.3.
This code demonstrates that Claude 3 Opus is a very capable model, able to learn from examples and write code in a manner required for our case. However, the code generated by the LLM needs to be executed to ensure correctness. For this, we sent the code to our code correction framework (as described in sub section 3.1.3), and the output of that framework after multiple correction iterations, is given in appendix:5.4.
You will be recreating the Python code for a specified research paper. The goal is to generate code that can be directly copied and pasted for execution. I will provide you with a series of prompts to guide you through the process. First, here is a sample paper for your reference: <sample_paper> {SAMPLE_PAPER} </sample_paper> And here is the sample code associated with the mathematical model from that paper: <sample_code> {SAMPLE_CODE} </sample_code> Note that the sample code may be entirely diferent from the paper you will be working with. It is only provided to give you an idea of how to proceed in creating the code for the mathematical model of the given paper. The mathematical expressions and logic in your paper may be diferent. Now, here is the paper you will be recreating the code for: <paper> {PAPER} </paper> Please carefully study the mathematical models and equations provided in this paper.
Next, write out the equations for all the formulas in the paper as Python functions, similar to how it was done in the sample code. First, you will need to figure out the logic and all the formulas. Then, write out each formula as a Python function.
If there are no mathematical models or formulas given in the paper, simply state "No mathematical models or formulas are present in this paper." When writing the code, make sure to write out the full formula for clarity. For example, instead of representing equation (3) as a comment like # equation (3), write out the entire equation. This will ensure completeness. It’s crucial that any generated results are complete and accurate. Double-check your work to ensure the code aligns with the paper’s specifications.
Please provide your generated code inside <code> tags like this: <code> Your generated code goes here. </code> You don’t need to provide the entire code all at once. I will provide more prompts in a sequence to guide you through the process. Let’s work together to recreate the code accurately and eficiently.
Once the mathematical model code is generated, it can
be integrated with optimization algorithm for
obtaining the configuration with optimal cost. It is achieved
with two steps, first code generation for optimization
algorithm and second integration of mathematical model
with optimization algorithm. The first step is performed ysis. Also, the current framework relies heavily on the
in this study, by providing the user provided research user input for the mathematical model, its parameters
article as context to LLM with prompt (Table:6), to gen- and optimization algorithm to be used. To reduce this
erate the code for optimization. Here we have illustrated dependency on user input, the external data repositories
the output of this approach for research article by Pa- (like the mathematical model repository and code error
tel and Rao [
In next step, prompt (given in table7), that instructs LLM to combine both the mathematical model and the optimization code to produce the final code for optimization.
This combined code was then passed through the code correction framework. The output of code correction framework is presented in appendix:5.6.
The LLM performed remarkably well in identifying and writing most of the code logic accurately. However, the final answer did not exactly match the results described in the paper, as some of the parameter values were guessed by LLM since it was not present in the article provided by user. Also the code generated by LLM relied on the pdf text, which did not have accurate information of mathematical model equation due to limitation of pdf text parsing.
This study introduced the HxLLM framework, leveraging Large Language Models (LLMs) to automate the design and optimization of heat exchangers (HEs). Our approach integrated mathematical model extraction, code generation, and error correction using a RAG framework. The LLMs efectively identified and generated initial code for the mathematical models, although initial responses often required corrections. Our results demonstrated that LLMs, when combined with RAG, ofer a promising tool for automating the design and optimization processes of HEs. This can lead to increased energy eficiency and reduced costs in the process industry. However, the study also highlighted the limitations of current LLM capabilities, particularly in handling diverse mathematical models and optimizing complex designs without substantial human input. Future work should focus on enhancing the LLM’s ability to parse complex information from various document formats and reducing reliance on user input by integrating extensive external data repositories.
Additionally, incorporating agent-based workflows may further improve the code generation process. These advancements will help create a more comprehensive and reliable framework for designing and optimizing diverse engineering systems.
Research articles are often in pdf format, and parsing these pdfs to text can result in loss of equation information, table or graph image information. In present study, we have ignored this loss of information. However, the concrete methodology to parse the information in pdf ifles or any other similar files which contains multiple type of information needs to formulated for better comprehension of context by LLMs. Combination of methods like, use of neural networks [35], vision transformer based models [36] or LLM based models [37, 38] can be explored further for overcoming this limitation. The code generation capability of the LLMs have improved in recent times, however LLMs require human inputs (prompts) code generation of complete design and optimization of heat exchangers and can not be achieved in one shot. This further can be improved with agent based workflows for better code generation. Also, the current benchmark studies does not consider requirements of such design and optimization workflows and can’t be used for evaluating the framework proposed in this study and human evaluation approach was selected for analarXiv:2402.09664. [31] B. Ni, M. J. Buehler, Mechagents: Large language def Tube_side_heat_transfer_coefficient(di,
Re, Pr, k): Nu = 0.023 * (Re**0.8) * (Pr**0.4) #
equation (6) hi = (Nu * k) / di return hi F = numerator * denominator # equation (20) return F def Sensible_heat(Cp_h,mh,Th_i,Th_o): Q = mh*Cp_h*(Th_i-Th_o) return Q def Shell_hydaulic_diameter(St, do): if St == 1.25*do: # square pitch
De = (1.27 / do) * (St**2 - 0.785*do**2) # equation (7a) else: # triangular pitch
De = (1.10 / do) * (St**2 - 0.917*do**2) # equation (7b) return De def calculate_DPt(s, L, di, rho, Vi, mu, mu0, m): DPt = s * ((0.092 * (L/di) * ((rho * Vi**2) /2) * ((mu/mu0)**(-m))) + 2.5) * ((rho * Vi**2) /2) # equation (16) return DPt def Cross_section_area(St, do, e, DG): As = (St - do) * e * DG / St # equation (8) return As def calculate_DPs(jf, DG, De, Le, rho, Vo, mu, mu0): DPs = 8 * jf * (DG/De) * (Le/DG) * ((rho * Vo**2)/2) * ((mu/mu0)**(-0.14)) # equation (16) return DPs def calculate_Cod(n, i, C_o):
X = np.arange(1, n + 1) # Create an array of X values from 1 to n terms = C_o / (1 + i) ** X C_od = np.sum(terms) return C_od def Calculate_Total_Cost(C, n, DG, do, m, rho_t, rho_s, s, mew_t, L, Kt, St, e, ms, mew_s, Ks, Rfi,
Rfo, Th_i, Th_o, Tc_i, Tc_o, Cp_h, Cp_c, etta, ny, H, Ce, i, kw, xw, jh, jf, mu0, m_exp): di = 0.8*do NT = Number_of_tubes(C, n, DG, do) Vi = Flow_velocity_tube(m, di, rho_t, NT, s) Re_t = Reynolds_number_tube(rho_t, Vi, di, mew_t) Pr_t = Prandtl_number(mew_t, Cp_c, Kt) hi = Tube_side_heat_transfer_coefficient( di, Re_t, Pr_t, Kt) De = Shell_hydaulic_diameter(St, do) As = Cross_section_area(St, do, e, DG) Vo = Flow_velocity_shell(ms, rho_s, As) Re_s = Reynolds_number_shell(ms, De, As, mew_s) Pr_s = Prandtl_number(mew_s, Cp_h, Ks) ho = Shell_Side_heat_transfer_coefficient(
Ks, De, Re_s, Pr_s, mew_s, mu0, jh) K = Overall_heat_transfer_coefficient(hi, di, do, Rfi, kw, xw, Rfo, ho) lmtd = LMTD(Th_i, Th_o, Tc_i, Tc_o) R = (Th_i - Th_o) / (Tc_o - Tc_i) P = (Tc_o - Tc_i) / (Th_i - Tc_i) F = Correction_factor(R, P) A = (m*Cp_c*(Tc_o-Tc_i))/(K*F*lmtd) Span = (A/(math.pi*do*NT)) a1 = 8000 a2 = 259.2 a3 = 0.93 # Exchanger made with Stainless steel for both shell and tubes C_i = a1 + a2 * (A**(a3/3)) P = 1 / etta * (((m / rho_t) * DPt) + ((ms / rho_s) * DPs)) C_o = P * Ce * H C_od = calculate_Cod(ny, i, C_o) C_tot = C_i + C_od return C_tot if __name__ == ""__main__"":
main()
This is the final result of the error-free mathematical code generated by the LLM. def Tube_side_heat_transfer_coefficient(Kt,di ,Re,Pr,L,d0,mew_t,mew_w): def Sensible_heat(ms,Cps,Tis,Tos): if Re < 2300: Q = ms*Cps*(Tis-Tos) ht = (Kt/di)*(3.657+(0.0677*(Re*Pr*(di/L return Q
)) **1.33)/(1+0.1*Pr*((Re*di/L)**0.3))) def calculate_DPt(rho_t,vt,L,dt,ft,n): elif 2300 < Re < 10000: p = 4 ft = calculate_friction_factor(Re) DPt = rho_t*vt**2/2 * ((L/dt)*ft + p) * n ht = (Kt/di)*((ft/8)*(Re-1000)*Pr) return DPt
/(1+12.7 *math.sqrt(ft/8)*(Pr**(2/3)-1))*(1+(di/L def calculate_DPs(fs,rho_s,vs,L,B,Ds,De): )**0.67) DPs = fs * rho_s*vs**2/2 * (L/B) * (Ds/De) return DPs else: ht = 0.027*(Kt/d0)*(Re**0.8)*(Pr**(1/3))
* ((mew_t/mew_w)**0.14) return ht return C_tot
import math # Rao-1 algorithm def rao1_update(Xu_v_w, Xbest_v_w, Xworst_v_w,
r1): return Xu_v_w + r1 * (Xbest_v_w
Xworst_v_w) # Rao-2 algorithm def rao2_update(Xu_v_w, Xbest_v_w, Xworst_v_w,
r1, r2, Xu_v_w_or_XU_v_w, XU_v_w_or_Xu_v_w): return Xu_v_w + r1 * (Xbest_v_w
Xworst_v_w) + r2 * (abs(Xu_v_w_or_XU_v_w) - abs(
XU_v_w_or_Xu_v_w)) # Rao-3 algorithm def rao3_update(Xu_v_w, Xbest_v_w, Xworst_v_w,
r1, r2, Xu_v_w_or_XU_v_w, XU_v_w_or_Xu_v_w): return Xu_v_w + r1 * (Xbest_v_w - abs(
Xworst_v_w)) + r2 * (abs(Xu_v_w_or_XU_v_w) - (
XU_v_w_or_Xu_v_w)) def run_optimization(Xu_v_w, Xbest_v_w, def Xworst_v_w, r1, r2, Xu_v_w_or_XU_v_w, cylindrical_roller_bearing_dynamic_capacity XU_v_w_or_Xu_v_w,D, d, n, Q, Po, Ef, (bm, lv, ro, ri, t, z, rho, bm, lv, gamma, Dr, gamma, Dr, le, Z): le, Z, alpha, epsilon, Tci, Thi, Rc, return 207.9 * bm * lv * teh, Cph, dPh, Phi, tec, Cpc, dPc, (1 + (1.04 * ((1-gamma)/(1+gamma)) Pci, Ci, Cod, c1, x1, l, h, c2, b, L, do, di): **(143/108))** """ Runs the optimization process using the Rao algorithms and objective functions. """ # Run Rao algorithms rao1_result = rao1_update(Xu_v_w,
Xbest_v_w, Xworst_v_w, r1) rao2_result = rao2_update(Xu_v_w,
Xbest_v_w, Xworst_v_w, r1, r2, Xu_v_w_or_XU_v_w, XU_v_w_or_Xu_v_w) rao3_result = rao3_update(Xu_v_w,
Xbest_v_w, Xworst_v_w, r1, r2, Xu_v_w_or_XU_v_w, XU_v_w_or_Xu_v_w) # Calculate objective functions helical_spring_result =
helical_spring_volume (D, d, n) hydrostatic_thrust_bearing_result =
hydrostatic_ thrust_bearing_power_loss(Q, Po, Ef) multiple_disc_clutch_brake_result = multiple_disc_clutch_brake_mass(ro, ri, t,
z, rho) cylindrical_roller_bearing_result =
cylindrical _roller_bearing_dynamic_capacity (bm, lv, gamma, Dr, le, Z) spherical_roller_bearing_result =
spherical _roller_bearing_dynamic_capacity (bm, lv, gamma, Dr, le, Z, alpha) plate _fin_heat_exchanger_result = plate _fin_heat_exchanger_entropy_generation (epsilon, Tci, Thi, Rc, teh, Cph, dPh, Phi, # Return results return { ’rao1_result’: rao1_result, ’rao2_result’: rao2_result, ’rao3_result’: rao3_result, ’helical_spring_result’: helical _spring_result, ’hydrostatic _thrust_bearing_result’: hydrostatic _thrust_bearing_result, ’multiple_disc_clutch_brake_result’:
multiple _disc_clutch_brake_result, ’cylindrical_roller_bearing_result’:
cylindrical _roller_bearing_result, ’spherical_roller_bearing_result’: spherical _roller_bearing_result, ’plate_fin_heat_exchanger_result’: plate_fin_heat_exchanger_result, ’shell_and_tube_heat_exchanger_result’:
shell _and_tube_heat_exchanger_result, ’welded_beam_result’: welded_beam_result
, ’belt_pulley_drive_result’:
belt_pulley_drive_result, ’hollow_shaft_result’:
hollow_shaft_result } 5.4. Final revised Mathematical model for the non-similar research article following the code correction framework # Spherical roller bearing objective function def spherical_roller_bearing_dynamic_capacity (bm, lv, gamma, Dr, le, Z, alpha):return 207.9 * bm * lv * (1 + import math (1.04 * ((1-gamma)/(1+gamma))**(143/108)) **(9/2))**(-2/9) * gamma**(2/9) * (1-gamma) # Rao-1 algorithm **(29/27) def rao1_update(Xu_v_w, Xbest_v_w, Xworst_v_w, * (1+gamma)**(1/4) * (le*math.cos(alpha)) r1): **(7/9) * Z**(3/4) * return Xu_v_w + r1 * (Xbest_v_w - Dr**(29/27)
Xworst_v_w) * (le)**(7/9) * Dr**(29/27) * Z**(3/4) # Rao-2 algorithm def rao2_update (Xu_v_w, Xbest_v_w, Xworst_v_w, r1, r2, Xu_v_w_or_XU_v_w, XU_v_w_or_Xu_v_w):
return Xu_v_w + r1 * (Xbest_v_w - Xworst_v_w) + r2 * (abs(Xu_v_w_or_XU_v_w) - abs(
XU_v_w_or_Xu_v_w)) # Rao-3 algorithm def rao3_update(Xu_v_w, Xbest_v_w, Xworst_v_w,
r1, r2, Xu_v_w_or_XU_v_w, XU_v_w_or_Xu_v_w):return Xu_v_w + r1 * (Xbest_v_w - abs(Xworst_v_w)) + r2 * (abs(Xu_v_w_or_XU_v_w) - (
XU_v_w_or_Xu_v_w)) Xu_v_w_or_XU_v_w, XU_v_w_or_Xu_v_w:
Parameters for Rao algorithms - D, d, n: Parameters for helical compression spring - Q, Po, Ef: Parameters for hydrostatic thrust bearing - ro, ri, t, z, rho: Parameters for multiple disc clutch brake - bm, lv, gamma, Dr, le, Z: Parameters for cylindrical roller bearing - alpha: Additional parameter for spherical roller bearing - epsilon, Tci, Thi, Rc, teh, Cph, dPh, Phi, tec, Cpc, dPc, Pci:
Parameters for plate fin heat exchanger - Ci, Cod: Parameters for shell and tube
heat exchanger - c1, x1, l, h, c2, b, L: Parameters for
welded beam - do, di: Additional parameters for hollow
shaft # Calculate objective functions helical_spring_result =
helical_spring_volume (D, d, n) hydrostatic_thrust_bearing_ result =
hydrostatic_thrust_bearing_power_loss (Q, Po, Ef) multiple_disc_clutch_brake_ result = multiple_disc_clutch_brake_mass (ro, ri, t, z, rho) cylindrical_roller_bearing_ result = cylindrical_roller_bearing_dynamic_capacity result = plate_fin_heat_exchanger_entropy_ generation (epsilon, Tci, Thi, Rc, teh, Cph, dPh, Phi,
tec, Cpc, dPc, Pci) shell_and_tube_heat_exchanger_ result =
shell_and_tube_heat_exchanger_total_cost (Ci, Cod) welded_beam_result = welded_beam_cost (c1, x1, t, l, h, c2, b, L) belt_pulley_drive_result =
belt_pulley_drive_weight (rho, b, d1, t1, d2, t2, d1_1, t1_1, d1_2,
t1_2) hollow_shaft_result = hollow_shaft_weight (do, di, L, rho) # Return results return { ’rao1_result’: rao1_result, ’rao2_result’: rao2_result, ’rao3_result’: rao3_result, ’helical_spring_result’:
helical_spring_result, ’hydrostatic_thrust_bearing_result’:
hydrostatic_ thrust_bearing_result, ’multiple_disc_clutch_brake_result’:
multiple_disc_ clutch_brake_result, ’cylindrical_roller_bearing_result’:
cylindrical_roller _bearing_result, ’spherical_roller_bearing_result’:
spherical_ roller_bearing_result, ’plate_fin_heat_exchanger_result’:
plate_fin_ heat_exchanger_result, ’shell_and_tube_heat_exchanger_result’:
shell_and_tube_ heat_exchanger_result, ’welded_beam_result’: welded_beam_result
, ’belt_pulley_drive_result’:
belt_pulley_drive_result, ’hollow_shaft_result’:
hollow_shaft_result } (bm, lv, gamma, Dr, le, Z) spherical_roller_bearing_ result = spherical_roller_bearing_dynamic_capacity 5.5. Initial code generation for optimization model outlined in the research article (bm, lv, gamma, Dr, le, Z, alpha) plate_fin_heat_exchanger_ def PSO (num_particles, max_iterations, w, c1, c2,
Ds_min,
Ds_max, do_min, do_max, B_min, B_max):
i][
Pr = (mew*Cp)/Kt return Pr def Shell_Side_heat_transfer_coefficient (Ks,De,Re,Pr,mew_s,mew_w): hs = 0.36*(Ks/De)*(Re**0.55) *(Pr**(1/3))*((mew_s/mew_w)**0.14) return hs def LMTD(Tis,Tos,Tit,Tot): deltaT1 = Tis - Tot deltaT2 = Tos - Tit lmtd = (deltaT1 - deltaT2) / math.log(
deltaT1 / deltaT2) return lmtd def Correction_factor(Tis, Tos, Tit, Tot):
R = (Tis - Tos) / (Tot - Tit) P = (Tot - Tit) / (Tis - Tit) numerator = math.sqrt(R**2 + 1) / (R - 1) * math.log((1 - P) / (1 - P*R)) denominator = math.log((2 - P* (R + 1 - math.sqrt(R**2 + 1))) / (2 - P*(R + 1 + math.sqrt(R**2 + 1)))) F = numerator / denominator return F def Sensible_heat(ms,Cps,Tis,Tos):
Q = ms*Cps*(Tis-Tos) return Q def calculate_DPt(rho_t,vt,L,dt,ft,n): p = 4 DPt = rho_t*vt**2/2 * ((L/dt)*ft + p) * n return DPt def calculate_DPs(fs,rho_s,vs,L,B,Ds,De):
DPs = fs * rho_s*vs**2/2 * (L/B) * (Ds/De) return DPs ht = Tube_side_heat_transfer_coefficient (Kt,di,Re_t,Pr_t,L,d0,mew_t,mew_w) U = 1/((1/hs)+Rfs+(d0/di)*(Rft+(1/ht))) lmtd = LMTD(Tis,Tos,Tit,Tot) F = Correction_factor(Tis,Tos,Tit,Tot) A = (mt*Cp_c*(Tot-Tit))/(U*F*lmtd) Span = (A/(pie*d0*Nt)) ft = calculate_friction_factor(Re_t) DPt = calculate_DPt(rho_t,vt,Span,di,ft,n) b0 = 0.72 fs = calculate_fs(b0, Re_s) vs = Flow_velocity_shell(ms,rho_s, Cross_section_area(Ds,b,C1)) DPs = calculate_DPs(fs,rho_s,vs,L,B,Ds,De) a1 = 8000 a2 = 259.2 a3 = 0.93 C_i = a1 + a2 * (A**(a3/3)) P = 1 / etta * (((mt / rho_t) * DPt) + ((ms / rho_s) * DPs)) C_o = P * Ce * H C_od = calculate_Cod(ny, i, C_o) C_tot = C_i + C_od return C_tot import random def PSO(num_particles, max_iterations, w, c1, c2, Ds_min, Ds_max, do_min, do_max, B_min,
B_max):
particles = []
velocities = []
best_positions = []
best_costs = []
global_best_position = None
global_best_cost = float(’inf’)
if cost < global_best_cost:
global_best_position = [Ds, do, B]
global_best_cost = cost
return global_best_position
print(f"Optimal values: Shell diameter =
{optimal_values[0]}, Tube outer diameter =
{optimal_values[
optimal_values[
Researchers have explored various surrogate modeling
approaches, including machine learning [
Fouling, the deposition of chemical compounds,
reduces the heat transfer eficiency of heat exchangers and
can lead to operational stoppages. Measuring the extent
of fouling is challenging due to the lack of direct
measurements. Recently, deep learning-based models have been
developed to provide real-time visibility and forecast the
health of heat exchangers, aiding in better planning and
optimization of operations [
Saeed et al. [