व्यायाम: 2 डी कक्षीय यांत्रिकी सिमुलेशन (अजगर)

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

आप किसी भी बिंदु पर इस परियोजना को लेने के लिए स्वतंत्र हैं और मजेदार प्रयोग कर रहे हैं!

अपडेट करें!!! (Nov10)

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

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

सुधार के लिए टिप्पणियाँ और सुझाव हमेशा स्वागत है!

Matplotlib पुस्तकालय के साथ Python3 में किया गया

import matplotlib.pyplot as plt
import math
plt.ion()

G = 6.673e-11  # gravity constant
gridArea = [0, 200, 0, 200]  # margins of the coordinate grid
gridScale = 1000000  # 1 unit of grid equals 1000000m or 1000km

plt.clf()  # clear plot area
plt.axis(gridArea)  # create new coordinate grid
plt.grid(b="on")  # place grid

class Object:
    _instances = []
    def __init__(self, name, position, radius, mass):
        self.name = name
        self.position = position
        self.radius = radius  # in grid values
        self.mass = mass
        self.placeObject()
        self.velocity = 0
        Object._instances.append(self)

    def placeObject(self):
        drawObject = plt.Circle(self.position, radius=self.radius, fill=False, color="black")
        plt.gca().add_patch(drawObject)
        plt.show()

    def giveMotion(self, deltaV, motionDirection, time):
        if self.velocity != 0:
            x_comp = math.sin(math.radians(self.motionDirection))*self.velocity
            y_comp = math.cos(math.radians(self.motionDirection))*self.velocity
            x_comp += math.sin(math.radians(motionDirection))*deltaV
            y_comp += math.cos(math.radians(motionDirection))*deltaV
            self.velocity = math.sqrt((x_comp**2)+(y_comp**2))

            if x_comp > 0 and y_comp > 0:  # calculate degrees depending on the coordinate quadrant
                self.motionDirection = math.degrees(math.asin(abs(x_comp)/self.velocity))  # update motion direction
            elif x_comp > 0 and y_comp < 0:
                self.motionDirection = math.degrees(math.asin(abs(y_comp)/self.velocity)) + 90
            elif x_comp < 0 and y_comp < 0:
                self.motionDirection = math.degrees(math.asin(abs(x_comp)/self.velocity)) + 180
            else:
                self.motionDirection = math.degrees(math.asin(abs(y_comp)/self.velocity)) + 270

        else:
            self.velocity = self.velocity + deltaV  # in m/s
            self.motionDirection = motionDirection  # degrees
        self.time = time  # in seconds
        self.vectorUpdate()

    def vectorUpdate(self):
        self.placeObject()
        data = []

        for t in range(self.time):
            motionForce = self.mass * self.velocity  # F = m * v
            x_net = 0
            y_net = 0
            for x in [y for y in Object._instances if y is not self]:
                distance = math.sqrt(((self.position[0]-x.position[0])**2) +
                             (self.position[1]-x.position[1])**2)
                gravityForce = G*(self.mass * x.mass)/((distance*gridScale)**2)

                x_pos = self.position[0] - x.position[0]
                y_pos = self.position[1] - x.position[1]

                if x_pos <= 0 and y_pos > 0:  # calculate degrees depending on the coordinate quadrant
                    gravityDirection = math.degrees(math.asin(abs(y_pos)/distance))+90

                elif x_pos > 0 and y_pos >= 0:
                    gravityDirection = math.degrees(math.asin(abs(x_pos)/distance))+180

                elif x_pos >= 0 and y_pos < 0:
                    gravityDirection = math.degrees(math.asin(abs(y_pos)/distance))+270

                else:
                    gravityDirection = math.degrees(math.asin(abs(x_pos)/distance))

                x_gF = gravityForce * math.sin(math.radians(gravityDirection))  # x component of vector
                y_gF = gravityForce * math.cos(math.radians(gravityDirection))  # y component of vector

                x_net += x_gF
                y_net += y_gF

            x_mF = motionForce * math.sin(math.radians(self.motionDirection))
            y_mF = motionForce * math.cos(math.radians(self.motionDirection))
            x_net += x_mF
            y_net += y_mF
            netForce = math.sqrt((x_net**2)+(y_net**2))

            if x_net > 0 and y_net > 0:  # calculate degrees depending on the coordinate quadrant
                self.motionDirection = math.degrees(math.asin(abs(x_net)/netForce))  # update motion direction
            elif x_net > 0 and y_net < 0:
                self.motionDirection = math.degrees(math.asin(abs(y_net)/netForce)) + 90
            elif x_net < 0 and y_net < 0:
                self.motionDirection = math.degrees(math.asin(abs(x_net)/netForce)) + 180
            else:
                self.motionDirection = math.degrees(math.asin(abs(y_net)/netForce)) + 270

            self.velocity = netForce/self.mass  # update velocity
            traveled = self.velocity/gridScale  # grid distance traveled per 1 sec
            self.position = (self.position[0] + math.sin(math.radians(self.motionDirection))*traveled,
                             self.position[1] + math.cos(math.radians(self.motionDirection))*traveled)  # update pos
            data.append([self.position[0], self.position[1]])

            collision = 0
            for x in [y for y in Object._instances if y is not self]:
                if (self.position[0] - x.position[0])**2 + (self.position[1] - x.position[1])**2 <= x.radius**2:
                    collision = 1
                    break
            if collision != 0:
                print("Collision!")
                break

        plt.plot([x[0] for x in data], [x[1] for x in data])

Earth = Object(name="Earth", position=(50.0, 50.0), radius=6.371, mass=5.972e24)
Moon = Object(name="Moon", position=(100.0, 100.0), radius=1.737, mass = 7.347e22)  # position not to real scale
Craft = Object(name="SpaceCraft", position=(49.0, 40.0), radius=1, mass=1.0e4)

Craft.giveMotion(deltaV=8500.0, motionDirection=100, time=130000)
Craft.giveMotion(deltaV=2000.0, motionDirection=90, time=60000)
plt.show(block=True)

यह काम किस प्रकार करता है

यह सब दो चीजों को उबालता है:

Earth = Object(name="Earth", position=(50.0, 50.0), radius=6.371, mass=5.972e24)ग्रिड पर स्थिति के मापदंडों के साथ ऑब्जेक्ट बनाना (1 यूनिट ग्रिड डिफ़ॉल्ट रूप से 1000 किमी है लेकिन इसे भी बदला जा सकता है), ग्रिड इकाइयों में त्रिज्या और किलो में द्रव्यमान।
वस्तु को कुछ डेल्टा जैसे कि Craft.giveMotion(deltaV=8500.0, motionDirection=100, time=130000)स्पष्ट रूप से इसे Craft = Object(...)पहले स्थान पर बनाने की आवश्यकता है जैसा कि पिछले बिंदु में बताया गया है। यहां पैरामीटर deltaVm / s में हैं (ध्यान दें कि अब त्वरण तात्कालिक है), motionDirectionडिग्री में डेल्टा की दिशा है (वर्तमान स्थिति से ऑब्जेक्ट के चारों ओर 360 डिग्री सर्कल की कल्पना करें, इसलिए दिशा उस सर्कल पर एक बिंदु है) और आखिरकार पैरामीटर timeकितने सेकंड में है वस्तु के डेल्टा धक्का प्रक्षेपवक्र के बाद नजर रखी जाएगी। बाद के giveMotion()पिछले स्थिति से शुरू करते हैं giveMotion()।

प्रशन:

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

मूल रूप से मेरा उद्देश्य विषय पर एक चर्चा शुरू करना है और देखना है कि यह कहां जाता है। और, यदि संभव हो, तो कुछ नया और रोचक सीखें (या बेहतर - सिखाएं)।

प्रयोग करने के लिए स्वतंत्र महसूस करो!

प्रयोग करके देखें:

Earth = Object(name="Earth", position=(50.0, 100.0), radius=6.371, mass=5.972e24)
Moon = Object(name="Moon", position=(434.0, 100.0), radius=1.737, mass = 7.347e22)
Craft = Object(name="SpaceCraft", position=(43.0, 100.0), radius=1, mass=1.0e4)

Craft.giveMotion(deltaV=10575.0, motionDirection=180, time=322000)
Craft.giveMotion(deltaV=400.0, motionDirection=180, time=50000)

दो बर्न के साथ - एक पृथ्वी की कक्षा में एक प्रतिगामी और चंद्रमा की कक्षा में एक प्रतिगामी मैंने स्थिर चंद्रमा की कक्षा हासिल की। क्या ये सैद्धांतिक अपेक्षित मूल्यों के करीब हैं?

सुझाया गया व्यायाम: इसे 3 बर्न में आज़माएँ - पृथ्वी की सतह से स्थिर पृथ्वी की कक्षा, चंद्रमा तक पहुँचने के लिए जलावन, चंद्रमा के चारों ओर की कक्षा को स्थिर करने के लिए प्रतिगामी जल। फिर डेल्टा को कम करने की कोशिश करें।

नोट: मैं उन लोगों के लिए व्यापक टिप्पणियों के साथ कोड को अपडेट करने की योजना बनाता हूं जो python3 सिंटैक्स से परिचित नहीं हैं।

orbit gravity n-body-simulations

— राज्य अंतरिक्ष
स्रोत

स्व-शिक्षा के लिए एक बहुत अच्छा विचार! क्या हम में से उन लोगों के लिए अपने सूत्रों को संक्षेप में प्रस्तुत करना संभव होगा जो पायथन सिंटैक्स से परिचित नहीं हैं?

पक्का मैंने सोचा। मैं उन लोगों के लिए कोड में अधिक व्यापक टिप्पणियां करूंगा जो इसे चुनना चाहते हैं और प्रश्न में सामान्य तर्क को संक्षेप में प्रस्तुत करते हैं।

— 21

मेरे सिर के ऊपर से: अलग गति और दिशा के इलाज के बजाय वेग के लिए एक वेक्टर का उपयोग करने पर विचार करें। जहाँ आप कहते हैं "F = m * v" क्या आपका मतलब "F = m * a" है? आप मान रहे हैं कि पृथ्वी हिलती नहीं है क्योंकि यह क्षुद्रग्रह से बहुत भारी है? पर देख रहे हैं पर विचार करें github.com/barrycarter/bcapps/blob/master/bc-grav-sim.pl

— barrycarter

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

— स्टेट्सस्पेस

ठीक। एक विचार: दो वास्तविक वस्तुओं (जैसे, पृथ्वी / चंद्रमा या पृथ्वी / सूर्य) के लिए सिमुलेशन करें और सटीकता के लिए अपने परिणामों की तुलना ssd.jpl.nasa.gov/?horizons से करें? यह अन्य स्रोतों द्वारा गड़बड़ी के कारण सही नहीं होगा, लेकिन यह आपको सटीकता का कुछ विचार देगा?

— बैरीकेटर

$m_1, m_2$

F = m a

$F = ma$

a

$a$

F_{21} = \frac{G m_{1} m_{2}}{| r_{21} |^{3}} r_{21}

$F_{21} = \frac{G m_1 m_2}{|r_{21}|^3}r_{21}$

$r_{21}$ $F_{12}=-F_{21}$ $r_{12}=-r_{21}$ $(x_1,y_1)$ $(x_2,y_2)$

r_{21} = (\begin{matrix} x_{1} - x_{2} \\ y_{1} - y_{2} \end{matrix}) .

$r_{21} = \begin{pmatrix} x_1-x_2 \\ y_1-y_2 \end{pmatrix}.$

तथा

| r | = \sqrt{(x_{1} - x_{2})^{2} + (y_{1} - y_{2})^{2}} .

$|r| = \sqrt{(x_1-x_2)^2 + (y_1-y_2)^2}.$

a = F / m

$a=F/m$

\begin{aligned} x_{1}^{″} (t) & = \frac{G m_{2} (x_{2} - x_{1})}{| r |^{3}} \\ y_{1}^{″} (t) & = \frac{G m_{2} (y_{2} - y_{1})}{| r |^{3}} \\ x_{2}^{″} (t) & = \frac{G m_{1} (x_{1} - x_{2})}{| r |^{3}} \\ y_{2}^{″} (t) & = \frac{G m_{1} (y_{1} - y_{2})}{| r |^{3}} . \end{aligned}

$\begin{align} x_1''(t) & = \frac{G m_2 (x_2-x_1)}{|r|^3} \\ y_1''(t) & = \frac{G m_2 (y_2-y_1)}{|r|^3} \\ x_2''(t) & = \frac{G m_1 (x_1-x_2)}{|r|^3} \\ y_2''(t) & = \frac{G m_1 (y_1-y_2)}{|r|^3}. \end{align}$

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

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

2-शरीर की समस्या के लिए अपने समन्वय प्रणाली को द्रव्यमान के केंद्र के आसपास आधार बनाकर एक सरल प्रणाली प्राप्त करना संभव है। लेकिन मुझे लगता है कि यदि आपके लिए यह नया है तो ऊपर दिया गया सूत्रीकरण स्पष्ट है।

— डेविड केचेसन
स्रोत

यह पचने में कुछ समय लेगा।

— स्टेट्सपेस

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

— स्टेट्सस्पेस

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

— च्रिसपप