एक सौर प्रणाली सिम्युलेटर बनाएं

प्रस्तावना
पायथन के रूप में इस तरह के एक अद्भुत प्रोग्रामिंग भाषा के अध्ययन के लिए एक नए के लिए शाश्वत लालसा। जैसा कि अक्सर होता है, एक विचार की कमी, जिसके कार्यान्वयन के लिए अपना समय बिताने के लिए कोई दया नहीं है, इस प्रक्रिया को बहुत बाधित किया।

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

इस पर क्या आया।

भाग एक सैद्धांतिक रूप से

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

हम समन्वय प्रणाली का परिचय देते हैं।

हमारे सिस्टम में दो निकाय हैं:
1. मास एम और केंद्र का एक विशाल तारा (x0, y0)
2. द्रव्यमान m का एक हल्का ग्रह, बिंदु (x, y), वेग v = (vx, vy) और त्वरण a = (ax, ay) पर केंद्रित है।

जब हम इस मामले को सुलझाने का प्रबंधन करते हैं, तो हम आसानी से एक दूसरे पर सितारों और ग्रहों के पारस्परिक प्रभाव के साथ जटिल प्रणालियों पर आगे बढ़ सकते हैं। अब हम सबसे सरल के बारे में बात करेंगे।

न्यूटन के दूसरे नियम, गुरुत्वाकर्षण के नियम और इसी तरह के त्रिभुजों के सरल हेरफेर के बाद, मैंने पाया कि:

ax = G * M * (x0-x) / r ^ 3
ay = G * M * (y0-y) / r ^ 3

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

1. शुरू करने से पहले, हम ग्रह की प्रारंभिक स्थिति (x, y) और प्रारंभिक गति (vx, vy) निर्धारित करते हैं
2. प्रत्येक चरण पर, हम ऊपर दिए गए सूत्र के अनुसार एक नए त्वरण की गणना करते हैं, उसके बाद हम गति और निर्देशांक का पुनरावर्तन करते हैं:

vx: = vx + T * कुल्हाड़ी
vy: = vy + T * कुल्हाड़ी

x: = x + T * vx
y: = y + T * yx

यह स्थिरांक जी और टी। पुट जी = 1 से निपटने के लिए बना हुआ है। हमारी समस्या के लिए, यह इतना महत्वपूर्ण नहीं है। पैरामीटर टी गणना की सटीकता और गति को प्रभावित करता है। भी शुरू करने के लिए 1 डाल दिया।

भाग दो व्यावहारिक

तो, मेरा पहला पायथन कार्यक्रम। उसी समय, एक बार फिर मैं व्यावहारिक मार्गदर्शन के लिए वेलेज़ को धन्यवाद देना चाहता हूं।

import pygame, math from pygame import * from math import * WIN_WIDTH = 800 WIN_HEIGHT = 640 PLANET_WIDTH = 20 PLANET_HEIGHT = 20 DISPLAY = (WIN_WIDTH, WIN_HEIGHT) SPACE_COLOR = "#000022" SUN_COLOR = "yellow" PLANET_COLOR = "blue" #Sun position X0 = WIN_WIDTH // 2 Y0 = WIN_HEIGHT // 2 #Sun mass M0 = 5000 #Stop conditions CRASH_DIST = 10 OUT_DIST = 1000 def main(): #PyGame init pygame.init() screen = pygame.display.set_mode(DISPLAY) pygame.display.set_caption("Solar Mechanics v0.1") #Space init bg = Surface((WIN_WIDTH,WIN_HEIGHT)) bg.fill(Color(SPACE_COLOR)) draw.circle (bg, Color(SUN_COLOR), (X0, Y0), 10) #Timer init timer = pygame.time.Clock() #Planet init planet = Surface((PLANET_WIDTH, PLANET_HEIGHT)) planet.fill(Color(SPACE_COLOR)) draw.circle (planet, Color(PLANET_COLOR), (PLANET_WIDTH // 2, PLANET_HEIGHT // 2), 5) #Planet to Sun distance r = 0.0 #Initial planet pos, speed and accel x = 100.0 y = 290.0 vx = 0.1 vy = 1.5 ax = 0.0 ay = 0.0 done = False while not done: timer.tick(50) for e in pygame.event.get(): if e.type == QUIT: done = True break r = sqrt((x - X0)**2 + (y - Y0)**2) ax = M0 * (X0 - x) / r**3 ay = M0 * (Y0 - y) / r**3 #New spped based on accel vx += ax vy += ay #New pos based on speed x += vx y += vy screen.blit(bg, (0, 0)) screen.blit(planet, (int(x), int(y))) pygame.display.update() if r < CRASH_DIST: done = True print("Crashed") break if r > OUT_DIST: done = True print("Out of system") break #Farewell print (":-)") if __name__ == "__main__": main() 

सिमुलेशन के कुछ समय बाद हमारा सिस्टम कैसा दिखता है



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

अब मैं दिलचस्प प्रणाली परिदृश्यों और छोटे इंटरफ़ेस सुधारों की तलाश कर रहा हूं।

यहाँ इस बात का उदाहरण दिया गया है कि वर्तमान में क्या विकास हो रहा है:


यदि यह नोट सकारात्मक समीक्षा से मिलता है, तो मैं एक नए संस्करण की कहानी जारी रखने का वादा करता हूं।

अपडेट:

1. मैं आलोचनाओं के लिए सभी टिप्पणीकारों का आभारी हूं। वे विचार के लिए महान भोजन प्रदान करते हैं।

2. प्रोजेक्ट बड़ा हो गया है। सभी निकाय पहले से ही स्वतंत्र हैं, सार्वभौमिक गुरुत्वाकर्षण के कानून के अनुसार एक-दूसरे को प्रभावित करते हैं। N ^ 2 इंटरैक्शन की गणना की जाती है।
अब बाहरी फाइलों में स्टार सिस्टम कॉन्फ़िगरेशन को स्टोर करना और स्टार्ट पर चयन करना संभव है
यहाँ कोड
इस तरह से चलाएं: python3.3 main.py -f <कॉन्फ़िगरेशन नाम> .ini
विभिन्न विन्यास एक ही स्थान पर हैं।

3. टिप्पणियों के लिए धन्यवाद, मुख्य दोष को खोजने और समाप्त करना संभव था - निर्देशांक की गणना करने की विधि।
अब Runge-Kutta विधि का उपयोग किया जाता है। जैसा कि मैंने "नॉन-टफ टास्क" पढ़ा, मैं नए तरीके सीखूंगा।