नमस्ते!

यहां हम एक निश्चित क्षेत्र के काम का वर्णन करते हैं और फिर कुछ सुंदर सुविधाओं को बनाते हैं (यहां सब कुछ बहुत आसान है)।

इस लेख में क्या होगा।

सामान्य मामला:

हम आधार का वर्णन करते हैं, अर्थात्, वैक्टर के साथ काम करते हैं (उन लोगों के लिए एक साइकिल जो हाथ पर सुन्न नहीं है)
हम बातचीत के भौतिक बिंदु और क्षेत्र का वर्णन करते हैं

विशेष मामला (सामान्य पर आधारित):

आइए विद्युत चुम्बकीय क्षेत्र शक्ति (पहले और तीसरे चित्र) के वेक्टर क्षेत्र का एक दृश्य बनाएं
हम एक विद्युत चुम्बकीय क्षेत्र में कणों की गति की कल्पना करेंगे

कट के नीचे मुझसे मिलो!

सैद्धांतिक पृष्ठभूमि प्रोग्रामिंग

वेक्टर

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

class Vector(list): def __init__(self, *el): for e in el: self.append(e)

यही है, अब हम एक वेक्टर बना सकते हैं

 v = Vector(1, 2, 3)

आइए अंकगणितीय ऑपरेशन को जोड़ दें:

 class Vector(list): ... def __add__(self, other): if type(other) is Vector: assert len(self) == len(other), "Error 0" r = Vector() for i in range(len(self)): r.append(self[i] + other[i]) return r else: other = Vector.emptyvec(lens=len(self), n=other) return self + other

बहुत बढ़िया:

 v1 = Vector(1, 2, 3) v2 = Vector(2, 57, 23.2) v1 + v2 >>> [3, 59, 26.2]

हम इसी तरह सभी अंकगणितीय कार्यों को परिभाषित करते हैं (वेक्टर का पूर्ण कोड कम होगा)। अब आपको दूरी फ़ंक्शन की आवश्यकता है। मैं एक देहाती डिस्टर्ब (v1, v2) बना सकता था - लेकिन यह सुंदर नहीं है, इसलिए% ऑपरेटर को फिर से परिभाषित करें:

 class Vector(list): ... def __mod__(self, other): return sum((self - other) ** 2) ** 0.5

बहुत बढ़िया:

 v1 = Vector(1, 2, 3) v2 = Vector(2, 57, 23.2) v1 % v2 >>> 58.60068258988115

हमें तेज वेक्टर पीढ़ी और सुंदर आउटपुट के लिए कुछ तरीकों की भी आवश्यकता है। यहाँ कुछ भी मुश्किल नहीं है, इसलिए यहाँ वेक्टर क्लास का पूरा कोड है:

सभी वेक्टर क्लास कोड

 class Vector(list): def __init__(self, *el): for e in el: self.append(e) def __add__(self, other): if type(other) is Vector: assert len(self) == len(other), "Error 0" r = Vector() for i in range(len(self)): r.append(self[i] + other[i]) return r else: other = Vector.emptyvec(lens=len(self), n=other) return self + other def __sub__(self, other): if type(other) is Vector: assert len(self) == len(other), "Error 0" r = Vector() for i in range(len(self)): r.append(self[i] - other[i]) return r else: other = Vector.emptyvec(lens=len(self), n=other) return self - other def __mul__(self, other): if type(other) is Vector: assert len(self) == len(other), "Error 0" r = Vector() for i in range(len(self)): r.append(self[i] * other[i]) return r else: other = Vector.emptyvec(lens=len(self), n=other) return self * other def __truediv__(self, other): if type(other) is Vector: assert len(self) == len(other), "Error 0" r = Vector() for i in range(len(self)): r.append(self[i] / other[i]) return r else: other = Vector.emptyvec(lens=len(self), n=other) return self / other def __pow__(self, other): if type(other) is Vector: assert len(self) == len(other), "Error 0" r = Vector() for i in range(len(self)): r.append(self[i] ** other[i]) return r else: other = Vector.emptyvec(lens=len(self), n=other) return self ** other def __mod__(self, other): return sum((self - other) ** 2) ** 0.5 def mod(self): return self % Vector.emptyvec(len(self)) def dim(self): return len(self) def __str__(self): if len(self) == 0: return "Empty" r = [str(i) for i in self] return "< " + " ".join(r) + " >" def _ipython_display_(self): print(str(self)) @staticmethod def emptyvec(lens=2, n=0): return Vector(*[n for i in range(lens)]) @staticmethod def randvec(dim): return Vector(*[random.random() for i in range(dim)])

सामग्री बिंदु

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

प्रारंभ इस प्रकार होगा:

 class Point: def __init__(self, coords, mass=1.0, q=1.0 speed=None, **properties): self.coords = coords if speed is None: self.speed = Vector(*[0 for i in range(len(coords))]) else: self.speed = speed self.acc = Vector(*[0 for i in range(len(coords))]) self.mass = mass self.__params__ = ["coords", "speed", "acc", "q"] + list(properties.keys()) self.q = q for prop in properties: setattr(self, prop, properties[prop])

और अपनी बात को आगे बढ़ाने और गति प्रदान करने के लिए, हम निम्नलिखित तरीके लिखेंगे:

 class Point: ... def move(self, dt): self.coords = self.coords + self.speed * dt def accelerate(self, dt): self.speed = self.speed + self.acc * dt def accinc(self, force): #        self.acc = self.acc + force / self.mass def clean_acc(self): self.acc = self.acc * 0

अच्छी तरह से किया, बिंदु ही किया जाता है।

प्वाइंट कोड (अच्छे आउटपुट के साथ)

 class Point: def __init__(self, coords, mass=1.0, q=1.0 speed=None, **properties): self.coords = coords if speed is None: self.speed = Vector(*[0 for i in range(len(coords))]) else: self.speed = speed self.acc = Vector(*[0 for i in range(len(coords))]) self.mass = mass self.__params__ = ["coords", "speed", "acc", "q"] + list(properties.keys()) self.q = q for prop in properties: setattr(self, prop, properties[prop]) def move(self, dt): self.coords = self.coords + self.speed * dt def accelerate(self, dt): self.speed = self.speed + self.acc * dt def accinc(self, force): self.acc = self.acc + force / self.mass def clean_acc(self): self.acc = self.acc * 0 def __str__(self): r = ["Point {"] for p in self.__params__: r.append(" " + p + " = " + str(getattr(self, p))) r += ["}"] return "\n".join(r) def _ipython_display_(self): print(str(self))

परिणाम:

सहभागिता क्षेत्र

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

 class InteractionField: def __init__(self, F): # F -   , F(p1, p2, r), p1, p2 - , r -    self.points = [] self.F = F def append(self, *args, **kwargs): self.points.append(Point(*args, **kwargs))

अब मज़े की बात यह है कि एक समारोह घोषित किया जाए जो उस बिंदु पर "तनाव" लौटाए। हालाँकि यह अवधारणा इलेक्ट्रोमैग्नेटिक इंटरैक्शन को संदर्भित करती है, हमारे मामले में यह कुछ अमूर्त वेक्टर है जिसके साथ हम बिंदु को स्थानांतरित करेंगे। इस मामले में, हमारे पास बिंदु q की संपत्ति होगी, विशेष मामले में - बिंदु का प्रभार (सामान्य रूप से - जो हम चाहते हैं, यहां तक कि वेक्टर भी)। तो बिंदु C पर तनाव क्या है? कुछ इस तरह:

v e c E (v e c C) = s u m v e c F_{i} (v e c C)

$\ vec E (\ vec C) = \ sum {\ vec F_i (\ vec C)}$

यानी बिंदु पर तनाव

v e c C

$\ vec C$ कुछ इकाई बिंदु पर अभिनय करने वाले सभी सामग्री बिंदुओं के बलों के योग के बराबर।

 class InteractionField: ... def intensity(self, coord): proj = Vector(*[0 for i in range(coord.dim())]) single_point = Point(Vector(), mass=1.0, q=1.0) #       (   ,       F,      ) for p in self.points: if coord % p.coords < 10 ** (-10): #      ,        ,   ,     (  ) continue d = p.coords % coord fmod = self.F(single_point, p, d) * (-1) #    -  proj = proj + (coord - p.coords) / d * fmod #  return proj

इस बिंदु पर, आप पहले से ही एक वेक्टर फ़ील्ड बना सकते हैं, लेकिन हम इसे अंत में करेंगे। अब हम अपनी बातचीत में एक कदम उठाते हैं

 class InteractionField: ... def step(self, dt): self.clean_acc() for p in self.points: p.accinc(self.intensity(p.coords) * pq) p.accelerate(dt) p.move(dt)

यहां सब कुछ सरल है। प्रत्येक बिंदु के लिए, हम इन निर्देशांक में तनाव का निर्धारण करते हैं और फिर ETU सामग्री बिंदु पर अंतिम बल निर्धारित करते हैं:

v e c F = v e c E * q

$\ vec F = \ vec E * q$

लापता कार्यों को परिभाषित करें।

सभी इंटरैक्शनफिल्ड कोड

 class InteractionField: def __init__(self, F): self.points = [] self.F = F def move_all(self, dt): for p in self.points: p.move(dt) def intensity(self, coord): proj = Vector(*[0 for i in range(coord.dim())]) single_point = Point(Vector(), mass=1.0, q=1.0) for p in self.points: if coord % p.coords < 10 ** (-10): continue d = p.coords % coord fmod = self.F(single_point, p, d) * (-1) proj = proj + (coord - p.coords) / d * fmod return proj def step(self, dt): self.clean_acc() for p in self.points: p.accinc(self.intensity(p.coords) * pq) p.accelerate(dt) p.move(dt) def clean_acc(self): for p in self.points: p.clean_acc() def append(self, *args, **kwargs): self.points.append(Point(*args, **kwargs)) def gather_coords(self): return [p.coords for p in self.points]

एक विशेष मामला। कण आंदोलन और वेक्टर क्षेत्र दृश्य

तो हम सबसे दिलचस्प हो गए। आइए शुरुआत करते हैं ...

एक विद्युत चुम्बकीय क्षेत्र में कणों की गति मॉडलिंग

 u = InteractionField(lambda p1, p2, r: 300000 * -p1.q * p2.q / (r ** 2 + 0.1)) for i in range(3): u.append(Vector.randvec(2) * 10, q=random.random() - 0.5)

दरअसल, गुणांक k कुछ प्रकार के बिलियन (9 * 10 ^ (- 9)) के बराबर होना चाहिए, लेकिन चूंकि यह समय t -> 0 से बुझ जाएगा, मैंने तुरंत दोनों को पर्याप्त संख्या में बनाने का फैसला किया। इसलिए, हमारे भौतिकी में k = 300'000। और सब कुछ के साथ, मुझे लगता है कि यह स्पष्ट है।

आर ** 2 + 0.1

- यह 0. से विभाजित करने से बचा जाता है। हम, ज़ाहिर है, भ्रमित हो सकते हैं, डिफॉर्म्स की एक बड़ी प्रणाली को हल कर सकते हैं, लेकिन सबसे पहले 2 से अधिक निकायों के लिए गति का कोई समीकरण नहीं है, और दूसरा यह "शुरुआती के लिए" लेख की अवधारणा में स्पष्ट रूप से शामिल नहीं है।

अगला, हम प्रत्येक अक्ष के साथ 0 से 10 तक निर्देशांक के साथ दस अंक (2-आयामी स्थान) जोड़ते हैं। इसके अलावा, हम प्रत्येक बिंदु को -0.25 से 0.25 तक चार्ज देते हैं। अब उनके समन्वय (और निशान) के अनुसार एक लूप बनाएं और अंक बनाएं:

 X, Y = [], [] for i in range(130): u.step(0.0006) xd, yd = zip(*u.gather_coords()) X.extend(xd) Y.extend(yd) plt.figure(figsize=[8, 8]) plt.scatter(X, Y) plt.scatter(*zip(*u.gather_coords()), color="orange") plt.show()

क्या होना चाहिए था:

वास्तव में, वहां ड्राइंग पूरी तरह से यादृच्छिक होगी, क्योंकि यांत्रिकी के विकास के क्षण में प्रत्येक बिंदु का प्रक्षेपवक्र अप्रत्याशित है।

वेक्टर फ़ील्ड विज़ुअलाइज़ेशन

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

 fig = plt.figure(figsize=[5, 5]) res = [] STEP = 0.3 for x in np.arange(0, 10, STEP): for y in np.arange(0, 10, STEP): inten = u.intensity(Vector(x, y)) F = inten.mod() inten /= inten.mod() * 4 #     res.append(([x - inten[0] / 2, x + inten[0] / 2], [y - inten[1] / 2, y + inten[1] / 2], F)) for r in res: plt.plot(r[0], r[1], color=(sigm(r[2]), 0.1, 0.8 * (1 - sigm(r[2])))) #        plt.show()

लगभग यह निष्कर्ष प्राप्त किया जाना चाहिए था।

आप स्वयं वैक्टर को लंबा कर सकते हैं, * 4 को 1.5 * से बदल सकते हैं:

हम आयामीता और मॉडलिंग के साथ खेलते हैं

200 अंकों और एक इंटरैक्शन के साथ पांच आयामी स्थान बनाएं जो दूरी के वर्ग पर निर्भर नहीं है, लेकिन 4 डिग्री पर।

 u = InteractionField(lambda p1, p2, r: 300000 * -p1.q * p2.q / (r ** 4 + 0.1)) for i in range(200): u.append(Vector.randvec(5) * 10, q=random.random() - 0.5)

अब सभी निर्देशांक, गति आदि को पांच आयामों में परिभाषित किया गया है। अब कुछ मॉडल करते हैं:

 velmod = 0 velocities = [] for i in range(100): u.step(0.0005) velmod = sum([p.speed.mod() for p in u.points]) #       velocities.append(velmod) plt.plot(velocities) plt.show()

यह किसी भी समय सभी गति के योग का एक ग्राफ है। जैसा कि आप देख सकते हैं, समय के साथ वे धीरे-धीरे तेज हो रहे हैं।

खैर, यह एक सरल निर्देश था कि इस तरह की एक साधारण चीज कैसे बनाई जाए। लेकिन अगर आप फूलों के साथ खेलते हैं तो क्या होता है:

डेमो के साथ सभी कोड

 import random class Vector(list): def __init__(self, *el): for e in el: self.append(e) def __add__(self, other): if type(other) is Vector: assert len(self) == len(other), "Error 0" r = Vector() for i in range(len(self)): r.append(self[i] + other[i]) return r else: other = Vector.emptyvec(lens=len(self), n=other) return self + other def __sub__(self, other): if type(other) is Vector: assert len(self) == len(other), "Error 0" r = Vector() for i in range(len(self)): r.append(self[i] - other[i]) return r else: other = Vector.emptyvec(lens=len(self), n=other) return self - other def __mul__(self, other): if type(other) is Vector: assert len(self) == len(other), "Error 0" r = Vector() for i in range(len(self)): r.append(self[i] * other[i]) return r else: other = Vector.emptyvec(lens=len(self), n=other) return self * other def __truediv__(self, other): if type(other) is Vector: assert len(self) == len(other), "Error 0" r = Vector() for i in range(len(self)): r.append(self[i] / other[i]) return r else: other = Vector.emptyvec(lens=len(self), n=other) return self / other def __pow__(self, other): if type(other) is Vector: assert len(self) == len(other), "Error 0" r = Vector() for i in range(len(self)): r.append(self[i] ** other[i]) return r else: other = Vector.emptyvec(lens=len(self), n=other) return self ** other def __mod__(self, other): return sum((self - other) ** 2) ** 0.5 def mod(self): return self % Vector.emptyvec(len(self)) def dim(self): return len(self) def __str__(self): if len(self) == 0: return "Empty" r = [str(i) for i in self] return "< " + " ".join(r) + " >" def _ipython_display_(self): print(str(self)) @staticmethod def emptyvec(lens=2, n=0): return Vector(*[n for i in range(lens)]) @staticmethod def randvec(dim): return Vector(*[random.random() for i in range(dim)]) class Point: def __init__(self, coords, mass=1.0, q=1.0, speed=None, **properties): self.coords = coords if speed is None: self.speed = Vector(*[0 for i in range(len(coords))]) else: self.speed = speed self.acc = Vector(*[0 for i in range(len(coords))]) self.mass = mass self.__params__ = ["coords", "speed", "acc", "q"] + list(properties.keys()) self.q = q for prop in properties: setattr(self, prop, properties[prop]) def move(self, dt): self.coords = self.coords + self.speed * dt def accelerate(self, dt): self.speed = self.speed + self.acc * dt def accinc(self, force): self.acc = self.acc + force / self.mass def clean_acc(self): self.acc = self.acc * 0 def __str__(self): r = ["Point {"] for p in self.__params__: r.append(" " + p + " = " + str(getattr(self, p))) r += ["}"] return "\n".join(r) def _ipython_display_(self): print(str(self)) class InteractionField: def __init__(self, F): self.points = [] self.F = F def move_all(self, dt): for p in self.points: p.move(dt) def intensity(self, coord): proj = Vector(*[0 for i in range(coord.dim())]) single_point = Point(Vector(), mass=1.0, q=1.0) for p in self.points: if coord % p.coords < 10 ** (-10): continue d = p.coords % coord fmod = self.F(single_point, p, d) * (-1) proj = proj + (coord - p.coords) / d * fmod return proj def step(self, dt): self.clean_acc() for p in self.points: p.accinc(self.intensity(p.coords) * pq) p.accelerate(dt) p.move(dt) def clean_acc(self): for p in self.points: p.clean_acc() def append(self, *args, **kwargs): self.points.append(Point(*args, **kwargs)) def gather_coords(self): return [p.coords for p in self.points] #  import matplotlib.pyplot as plt import numpy as np import time #     if False: u = InteractionField(lambda p1, p2, r: 300000 * -p1.q * p2.q / (r ** 2 + 0.1)) for i in range(10): u.append(Vector.randvec(2) * 10, q=(random.random() - 0.5) / 2) X, Y = [], [] for i in range(130): u.step(0.0006) xd, yd = zip(*u.gather_coords()) X.extend(xd) Y.extend(yd) plt.figure(figsize=[8, 8]) plt.scatter(X, Y) plt.scatter(*zip(*u.gather_coords()), color="orange") plt.show() def sigm(x): return 1 / (1 + 1.10 ** (-x/1000)) #    if False: u = InteractionField(lambda p1, p2, r: 300000 * -p1.q * p2.q / (r ** 2 + 0.1)) for i in range(3): u.append(Vector.randvec(2) * 10, q=random.random() - 0.5) fig = plt.figure(figsize=[5, 5]) res = [] STEP = 0.3 for x in np.arange(0, 10, STEP): for y in np.arange(0, 10, STEP): inten = u.intensity(Vector(x, y)) F = inten.mod() inten /= inten.mod() * 1.5 res.append(([x - inten[0] / 2, x + inten[0] / 2], [y - inten[1] / 2, y + inten[1] / 2], F)) for r in res: plt.plot(r[0], r[1], color=(sigm(r[2]), 0.1, 0.8 * (1 - sigm(r[2])))) plt.show() #    5-  if False: u = InteractionField(lambda p1, p2, r: 300000 * -p1.q * p2.q / (r ** 4 + 0.1)) for i in range(200): u.append(Vector.randvec(5) * 10, q=random.random() - 0.5) velmod = 0 velocities = [] for i in range(100): u.step(0.0005) velmod = sum([p.speed.mod() for p in u.points]) velocities.append(velmod) plt.plot(velocities) plt.show()

अगला लेख शायद अधिक जटिल मॉडलिंग के बारे में होगा, और शायद तरल पदार्थ और नवियर-स्टोक्स समीकरण।
UPD: मेरे सहयोगी द्वारा यहां लिखा गया एक लेख

वीडियो रेंडर करने में मदद करने के लिए मोमोदेव को धन्यवाद।

अजगर + matplotlib में कस्टम शारीरिक बातचीत का प्राथमिक अनुकरण