सौर मंडल का सिम्युलेटर। शुरू करने की कुंजी!

सिम्युलेटर के पहले भाग में , मैंने खेल के नियमों और उनके सबसे सरल कार्यान्वयन का वर्णन किया।

मैं उन सभी का आभारी हूं जिन्होंने पहले संस्करण पर रचनात्मक टिप्पणियां छोड़ीं। इससे मुझे समस्या की गहराई की सराहना करने में मदद मिली। Kahi4 , Ethril , Uri और lexasss के उपयोगकर्ताओं के लिए विशेष धन्यवाद


अब सिम्युलेटर बड़ा हो गया है। सभी निकाय सामान्य नियमों के अनुसार एक-दूसरे को प्रभावित करते हैं, यूलर विधि अतीत की बात है, अब सिमुलेशन, आदि के लिए सिस्टम चुनना संभव है।

एक नियंत्रित तंत्र के साथ अंतरिक्ष की विशालता को जीतने के लिए - आगे बढ़ने का समय है।

रास्ता साफ है
कि आपकी उड़ान समाप्त हो रही है
हम आपको याद करते हैं, शोक और प्यार।
आपका MCC

बुलबुले

हमारा लक्ष्य साम्यवाद है। रॉकेट का कारखाना

तो, स्पेससिम स्टार सिस्टम सिम्युलेटर आपको सिस्टम की प्रारंभिक स्थिति सेट करने और उसके व्यवहार को मॉडल करने की अनुमति देता है।

अब कल्पना कीजिए कि हमारे पास एक क्लासिक परिपूर्ण एकल-चरण रॉकेट रॉकेट है

बता दें कि रॉकेट में एक सूखा द्रव्यमान है,
यह ईंधन द्रव्यमान mf से भरा है
इंजन जोर - z
और ईंधन की खपत - एन
बता दें कि इंजन में असीमित संसाधन और असीमित संख्या में स्टार्ट होते हैं।

मान लीजिए कि हमारा रॉकेट द्रव्यमान एम और त्रिज्या एच के ग्रह की सतह पर स्थित है। हमारा मुख्य कार्य ग्रह के चारों ओर एक गोलाकार कक्षा में रॉकेट को लॉन्च करना होगा।

आगे स्वर्ग

एक गोलाकार कक्षा में प्रवेश करने से पहले, हम अपने रॉकेट को लंबवत रूप से ऊपर की ओर लॉन्च करते हैं और इसके आंदोलन का निरीक्षण करते हैं।
एक रॉकेट पर दो बल कार्य करते हैं:
1. इंजन जोर (ऊपर): एफ = एन * जेड
2. ग्रह गुरुत्वाकर्षण (नीचे): एफ = जी * एम * (एम + एमएफ) / आर ^ 2, एम + एमएफ - रॉकेट का कुल द्रव्यमान, आर - रॉकेट से ग्रह के केंद्र तक दूरी।

नीचे हर जगह, हम G = 1 सेट करेंगे

रॉकेट पर परिणामी बल अभिनय होगा: n * z - G * M * (m + mf) / r ^ 2
यहाँ से आप रॉकेट का त्वरण पा सकते हैं:

a = n * z / (m + mf) - M / r ^ 2

अब आप आसानी से ग्रह के गुरुत्वाकर्षण के प्रभाव के तहत ऊपर की ओर रॉकेट आंदोलन की गणना आसानी से कर सकते हैं:

यूलर की विधि:

H=409.0 #Start level above sea t=0 m=2 #Mass of equipment mf=9 #Mass of Fuel M=600000 #Planet mass y=H + 1 #Initial position a=0 #accel v=0 #speed f=0 #engine accel n=1 #Fuel consumption z=40.0 #Fuel impulse cnt = 0 #Step count dt = .1 maxy = 0 while(y > H and cnt < 300000000): if mf > 0: f = n*z/(m + mf) #Engine gives acceleration to mf -= dt*n #Fuel goes down else: f = 0 #Out of fuel a = f - M/y**2 #Total = engine - gravity v += dt*a #new speed y += dt*v #new altitude maxy = max(maxy, y) print("Step: ", cnt, " Height: ", y, " VSpeed: ", v) cnt += 1 print(dt ,maxy) 

रनगे-कुट्टा विधि

 H=409.0 #Start level above sea t=0 m=2 #Mass of equipment mf=9 #Mass of Fuel M=600000 #Planet mass x=H + 1 #Initial position a=0 #accel v=0 #speed f=0 #engine accel n=1 #Fuel consumption z=40.0 #Fuel impulse cnt = 0 #Step count dt = .1 maxy = 0 def f(t, x, v): global m,mf,n,z if mf > 0: f = n*z/(m + mf) #Engine gives acceleration to else: f = 0 #Out of fuel a = f - M/x**2 #Total = engine - gravity #We'll use Runge-Kutta method return a #new speed def g(t, x, v): return v while(x > H and cnt < 30000): maxy = max(maxy, x) k1 = dt * f(t, x, v) q1 = dt * g(t, x, v) k2 = dt * f(t + dt/2, x + q1/2, v + k1/2) q2 = dt * g(t + dt/2, x + q1/2, v + k1/2) k3 = dt * f(t + dt/2, x + q2/2, v + k2/2) q3 = dt * g(t + dt/2, x + q2/2, v + k2/2) k4 = dt * f(t + dt, x + q3, v + k3) q4 = dt * g(t + dt, x + q3, v + k3) v1 = v + (k1 + 2*k2 + 2*k3 + k4)/6 x1 = x + (q1 + 2*q2 + 2*q3 + q4)/6 print("Step: ", cnt, " Height: ", x1, " Speed: ", v1) cnt += 1 t += dt v = v1 x = x1 if mf > 0: mf -= dt*n #Fuel goes down print(dt ,maxy) 

जैसा कि आप देख सकते हैं, परिणाम बड़ी सटीकता के साथ मेल खाते हैं

यह सब एक साथ रखना

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

उन्हें मिलाएं! सिम्युलेटर में एक रॉकेट जोड़ें।

रॉकेट पर प्रोग्राम चलाने वाले ऑन-बोर्ड कंप्यूटर को जोड़ें।
एक गोलाकार कक्षा में प्रवेश करने के लिए, यह इस एल्गोरिथ्म के अनुसार कार्य करेगा:

1. इंजन शुरू करें और रॉकेट ऊपर उड़ना शुरू कर देता है।
2. इंजन बंद करें। रॉकेट जड़ता से उड़ता है
3. रॉकेट बॉडी को 90 डिग्री पर घुमाएं।
4. उस समय जब ऊर्ध्वाधर गति शून्य के बराबर हो जाती है, इंजन चालू करें
5. थोड़े समय के बाद, इंजन बंद कर दें।

और यह है कि कार्यान्वयन कैसे दिखता है:

 class EarthOrbiter(Rocket): def flightProgram(self): #Take off and turn 90" right if self.mode == 0: self.engineOn() self.mode = 1 if self.t > 12.0 and self.mode == 1: self.engineOff() self.setHead(90) self.mode = 2 #Go to round orbit if self.t > 20 and self.mode == 2: self.engineOn() self.mode = 3 if self.t >= 27 and self.mode == 3: self.engineOff() self.mode = 4 

हमारे रॉकेट में होने वाली घटनाएं उड़ान के समय और पिछली स्थिति के आधार पर होती हैं।

बिंगो! उड़ान सामान्य है। प्रक्षेपवक्र स्थिर है।

यहाँ एक छोटी पहली उड़ान फिदेओ है:
उड़ान वीडियो 1
उड़ान वीडियो २
हम चाँद पर उड़ते हैं!

अगला कदम सिस्टम में चंद्रमा को जोड़ना और उस पर उड़ान भरना है।
इसके अलावा योजनाओं में बहु-मंचीय मिसाइलें हैं।

सूत्र - यहाँ

Update1: चंद्रमा के लिए उड़ान गयी।
ग्रहों पर मिसाइलों को उतारने की क्षमता को जोड़ा।

अपडेट 2: दो अंतरिक्ष यान को डॉक करने की क्षमता को जोड़ा।