🕛 🏨 💿 डमी के लिए जलमग्न सीमा विधि 👨‍❤️‍👨 ⛓️ 🚏

"शुद्ध" और "लागू गणितज्ञों" के बीच का रिश्ता विश्वास और समझ पर आधारित है। "शुद्ध गणितज्ञ" "लागू गणितज्ञों" पर भरोसा नहीं करते हैं, और "लागू गणितज्ञों" शुद्ध गणितज्ञों को नहीं समझते हैं।

कुछ समय पहले, मुझे इस तथ्य का सामना करना पड़ा था कि मुझे सुलभ सामग्री नहीं मिल सकती है जिसमें डूबे हुए सीमा पद्धति को महान और शक्तिशाली पर वर्णित किया जाएगा। संक्षेप में, यह कम्प्यूटेशनल तरल गतिकी का एक तरीका है, जो हमें उन वस्तुओं के आसपास प्रवाह की गणना करने की अनुमति देता है जो आकार और गतिशीलता में काफी जटिल हैं। इसलिए इस विषय पर रूसी भाषा के प्रकाशन बेहद अपर्याप्त थे। "मुझे कोई फर्क नहीं पड़ता, हम विदेशी सहयोगियों के कार्यों को पढ़ेंगे," मैंने सोचा। लेकिन यहां एक छोटी सी पकड़ इंतजार कर रही थी - इस पद्धति पर सभी उपलब्ध सामग्री और प्रकाशन बहुत सैद्धांतिक थे, और मेरे लिए (निश्चित रूप से, शायद यह केवल मेरी विशेषता नहीं है) आमतौर पर सैद्धांतिक गणनाओं से कोड में अधिक या कम अवतार के लिए संक्रमण करना मुश्किल होता है। इसलिए, मैं (और बुद्धिमान व्यक्तियों से सलाह के लिए आशा की कुछ डिग्री के साथ) के रूप में एक ही दुर्भाग्यपूर्ण लोगों के लिए, मैंने इस पद्धति का एक संक्षिप्त विवरण बनाने और इसे लागू करने का सबसे आसान तरीका प्रदान करने का फैसला किया।

मैं केवल मूल पेस्किन विधि पर विचार करूंगा, क्योंकि मेरी राय में, यह डमी कोशिकाओं (भूत-कोशिकाओं) की विधि, छोटी कोशिकाओं (कट-सेल) की विधि और उनके सभी अन्य संशोधनों की तुलना में सरल है।

तो, विकिपीडिया हमें बताता है कि "डूबे हुए सीमा पद्धति" एक तरल और एक सुव्यवस्थित वस्तु के बीच बातचीत को मॉडलिंग करने के लिए एक दृष्टिकोण है (क्योंकि यह अक्सर जैविक प्रणालियों में पतले फाइबर को मॉडल करने के लिए उपयोग किया जाता है, कभी-कभी वे "फाइबर" शब्द का उपयोग करते हैं) )। और यह सच है =)
इस दृष्टिकोण की मुख्य विशेषता यह है कि द्रव प्रवाह (यूलर निर्देशांक में) की गणना के लिए और जलमग्न सीमा के मापदंडों की गणना के लिए (लैग्रान्ज निर्देशांक में उन्हीं फाइबर फाइबर) की गणना के लिए दो अलग-अलग ग्रिड पेश किए जाते हैं। यह तरल पदार्थ की गणना के लिए सरल ग्रिड और तेज कम्प्यूटेशनल विधियों का उपयोग करना संभव बनाता है, अनुकार की पूरी जटिलता को विसर्जित सीमा के साथ बातचीत के चरण में स्थानांतरित करता है।

विशुद्ध रूप से सैद्धांतिक दृष्टिकोण से, इस तरह के एक चाल को तरल पर डूबे सीमा की कार्रवाई के बल (अधिक सटीक, बल घनत्व) के बल पर नवियर-स्टोक्स समीकरण को जोड़कर किया जाता है:

$\ rho (\ frac {\ आंशिक u} {\ आंशिक t} + (u \ cdot \ nabla) u) + \ nabla p = \ nu \ त्रिकोण u + f$

इस बल की गणना किसी तरह डूबे हुए सीमा के परिकलित बिंदुओं के स्थान के आधार पर की जाती है, और प्रवाह को बदल देती है। समीकरणों की पूरी प्रणाली इस तरह दिखती है:

$\ rho (\ frac {\ आंशिक u} {\ आंशिक t} + (u \ cdot \ nabla) u) + \ nabla p = \ nu \ त्रिकोण u + f$
$\ n नबला यू = ०$
$f (x, t) = \ int_ \ Omega F (q, r, s, t) \ डेल्टा (x-X (q, r, s, t)) \; dq \ _; dr \ _; डी एस$
$\ frac {\ आंशिक X} {\ आंशिक t} (q, r, s, t) = \ int_U u (x, t) \ डेल्टा (x-X (q, r, s, t) \ _; dx$

जलमग्न सीमा पर सीमा की स्थिति के साथ, उदाहरण के लिए, इस रूप की (आसंजन स्थिति उर्फ "नो-स्लिप"):

$\ frac {\ आंशिक X} {\ आंशिक t} (q, r, s, t) = u (X (q, r, s, t), t)$

समीकरणों की इस प्रणाली में $f, \; u; \; x;$ - ऐसे चर हैं जो क्षेत्र में द्रव के प्रवाह का वर्णन करते हैं

निर्देशांक के साथ $(x, y, z) \ u में$ , और $एफ, \; यू$ - चर जो क्षेत्र में डूबे हुए सीमा की स्थिति का वर्णन करते हैं $\ _ ओमेगा$ निर्देशांक के साथ $(क्यू, आर, एस) \ ओमेगा में$ ।

दरअसल, तरल पदार्थ और सीमा का अंतर्कलह पिछले दो समीकरणों में छिपा होता है।

यदि हम कार्यान्वयन के दृष्टिकोण से इस सभी अपमान पर विचार करते हैं, तो प्रत्येक बार चरण के लिए एल्गोरिथ्म लगभग निम्नानुसार होगा:

डूबे हुए सीमा के प्रत्येक बिंदु पर, हम इसकी वर्तमान स्थिति के आधार पर वोल्टेज की ताकत की गणना करते हैं
हम तरल के बिंदुओं के लिए कुछ एल्गोरिदम के अनुसार प्राप्त बल वितरित करते हैं
हम प्राप्त बल को ध्यान में रखते हुए, द्रव प्रवाह के मापदंडों की गणना करते हैं
हम तरल पदार्थ के बिंदुओं से जलमग्न सीमा के नोड्स तक वेग को प्रक्षेपित करते हैं (सीमा की स्थिति के कारण, सीमा के वेग को द्रव के वेग के साथ मेल खाना चाहिए)
सीमा नोड्स की स्थिति को गति के अनुसार बदलें

जैसा कि आप देख सकते हैं, एल्गोरिथ्म में दो अनिश्चित बिंदु हैं - कुछ भी नहीं कहा जाता है कि वोल्टेज की ताकत कैसे निर्धारित की जाए, साथ ही साथ द्रव प्रवाह के मापदंडों की गणना कैसे करें। यह इस दृष्टिकोण का एक गंभीर प्लस है - ये विधियाँ लगभग कोई भी हो सकती हैं =) लेकिन कार्यान्वयन के करीब होने के लिए, मुझे कम से कम इस बारे में बात करनी होगी कि सीमा पर वोल्टेज की गणना कैसे की जाए (दूसरा तरीका वास्तव में मनमाने ढंग से चुना जा सकता है, यदि केवल बहुत सटीक था)।

वास्तव में, कठिन लोग उस बल को खोजते हैं जो ऊर्जा कार्यात्मक का उपयोग करके सीमा पर बनता है और तन्यता बल और झुकने वाले बल को ध्यान में रखता है। लेकिन अपने अफसोस के लिए, मैं अब भी इस क्षण का पूरी तरह पता नहीं लगा पाया हूं। इसलिए, आप कम सटीक, लेकिन गणना, दंड विधि के लिए पर्याप्त धोखा दे सकते हैं और उपयोग कर सकते हैं। इसका सार सरल है - आगे सीमा अपनी मूल स्थिति से विचलित हो जाती है, उभरती हुई ताकत जितनी अधिक होती है। नतीजतन, केवल विचलन की गणना करना और एक निश्चित कठोरता गुणांक द्वारा गुणा करना आवश्यक है, जिसके साथ आप इसे माप सकते हैं।

एल्गोरिथ्म में दूसरा सूक्ष्म बिंदु डेल्टा फ़ंक्शन है, जो समीकरणों की प्रणाली में दिखाई दिया। हमें इसके संख्यात्मक संस्करण की आवश्यकता है और, एक अच्छे तरीके से, यह पूरा गीत है, क्योंकि इसके विवेक के लिए विकल्प एक विशाल बादल है। लेकिन इस मामले में, आप उन सहयोगियों के अनुभव पर भरोसा कर सकते हैं जो इसका उपयोग करने की सलाह देते हैं (इसी तरह तीन आयामी मामले के लिए):

$D_ {ij} (\ bm x) = d (x-ih) (y-jh)$
$d (r) = \ frac {1} {4h} (1 + cos (\ frac {\ pi r} {2h})), \; \ _ r \ _ | <2h$
$डी (आर) = 0, \; \ _ r \ _ | \ geq 2 ज$

अब, एक हजार शब्दों के बजाय, आप कोड के रूप में परिणामी एल्गोरिदम का वर्णन कर सकते हैं।

नोड्स पर वोल्टेज की गणना कुछ इस तरह दिख सकती है:

for(int n = 0; n < boundary->nodes_count; ++n) { Node *node = &boundary->nodes[n]; // get_area   ,      node->x_force = -boundary->stiffness * (node->x - node->x_ref) * boundary->get_area(); node->y_force = -boundary->stiffness * (node->y - node->y_ref) * boundary->get_area(); node->z_force = -boundary->stiffness * (node->z - node->z_ref) * boundary->get_area(); }

तरल के बिंदुओं पर बल का वितरण:

  for(int n = 0; n < boundary->nodes_count; ++n) { //         int x_int = index(boundary->nodes[n].x, COORD_X); int y_int = index(boundary->nodes[n].y, COORD_Y); int z_int = index(boundary->nodes[n].z, COORD_Z); // ..    -    , //       ,     //   (    )   for(int i = x_int-1; i <= x_int + 2; ++i) { for(int j = y_int-1; j <= y_int + 2; ++j) { for(int k = z_int-1; k <= z_int + 2; ++k) { //          long double dist_x = fabs(boundary->nodes[n].x - coord(i, COORD_X)); long double dist_y = fabs(boundary->nodes[n].y - coord(j, COORD_Y)); long double dist_z = fabs(boundary->nodes[n].z - coord(k, COORD_Z)); long double weight_x = delta(dist_x, COORD_X); long double weight_y = delta(dist_y, COORD_Y); long double weight_z = delta(dist_z, COORD_Z); //        force_X[i][j][k] += (boundary->nodes[n].x_force * weight_x * weight_y * weight_z) * boundary->get_area(); force_Y[i][j][k] += (boundary->nodes[n].y_force * weight_x * weight_y * weight_z) * boundary->get_area(); force_Z[i][j][k] += (boundary->nodes[n].z_force * weight_x * weight_y * weight_z) * boundary->get_area(); } } }

किसी भी उपयुक्त विधि से, हम प्रवाह की गणना करते हैं। फिर हम तरल के नोड्स के वेग को प्रक्षेपित करते हैं:

  for(int n = 0; n < boundary->nodes_count; ++n) { //    ,    int x_int = index(boundary->nodes[n].x, COORD_X); int y_int = index(boundary->nodes[n].y, COORD_Y); int z_int = index(boundary->nodes[n].z, COORD_Z); //       for(int i = x_int-1; i <= x_int + 2; ++i) { for(int j = y_int-1; j <= y_int + 2; ++j) { for(int k = z_int-1; k <= z_int + 2; ++k) { long double dist_x = fabs(boundary->nodes[n].x - coord(i, COORD_X)); long double dist_y = fabs(boundary->nodes[n].y - coord(j, COORD_Y)); long double dist_z = fabs(boundary->nodes[n].z - coord(k, COORD_Z)); long double weight_x = delta(dist_x, COORD_X); long double weight_y = delta(dist_y, COORD_Y); long double weight_z = delta(dist_z, COORD_Z); boundary->nodes[n].x_vel += (velocity_U[i][j][k] * weight_x * weight_y * weight_z) * CB(Hx[i]); boundary->nodes[n].y_vel += (velocity_V[i][j][k] * weight_x * weight_y * weight_z) * CB(Hy[j]); boundary->nodes[n].z_vel += (velocity_W[i][j][k] * weight_x * weight_y * weight_z) * CB(Hz[k]); } } } }

डूबे सीमा के नोड्स के निर्देशांक को अद्यतन करना:

  for(int n = 0; n < boundary->nodes_count; ++n) { boundary->nodes[n].x += boundary->nodes[n].x_vel; boundary->nodes[n].y += boundary->nodes[n].y_vel; boundary->nodes[n].z += boundary->nodes[n].z_vel; }

दरअसल, बस इतना ही। इस दृष्टिकोण में, यह माना जाता है कि सीमा लचीली है, लेकिन पर्याप्त रूप से उच्च कठोरता के साथ (यह वास्तव में विशाल होना चाहिए, प्रयोगों में विचार करें), आप एक ठोस सीमा के व्यवहार का अनुकरण कर सकते हैं।
मैं ध्यान देता हूं कि इस समय मैं द्रव के प्रवाह की गणना करने के लिए न्यूनतम अवशिष्टों के अपूर्ण सन्निकटन की विधि का उपयोग करता हूं, और स्थिर गणना की एक श्रृंखला द्वारा प्रारंभिक गैर-स्थिर समस्या का भी अनुमान लगाता हूं। यह, ज़ाहिर है, सबसे अच्छा विकल्प नहीं है, और आपको ऐसा नहीं करना चाहिए - लेकिन फिर भी यह काम करता है।

सब कुछ, मैं इस पाठ को दया करता हूं। सभी युक्तिकरण टिप्पणियों और सुझावों को स्वीकार किया जाता है, जैसा कि काम अभी भी आदर्श से बहुत दूर है।
शुरुआत के लिए, एक पर्याप्त उच्च चिपचिपाहट (और काफी मोटे ग्रिड पर) क्षेत्र के आसपास कुछ तस्वीरें।

डमी के लिए जलमग्न सीमा विधि

More articles: