अजीब परिणाम के साथ 3-क्रम बनाम 4-क्रम सहानुभूति इंटीग्रेटर का परीक्षण

में मेरा उत्तर एक को एमएसई पर सवाल एक 2D Hamiltonian भौतिकी सिमुलेशन के बारे में, मैं एक उच्च क्रम का उपयोग कर सुझाव दिया है symplectic समकलक ।

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

( Leap2 ) विकिपीडिया के 2-क्रम उदाहरण जिसके साथ मैं, परिचित हूँ हालांकि मैं नाम के तहत यह पता मेंढक कूद ,
( रूथ 3 ) रूथ के 3-क्रम सहानुभूति समन्वयक ,
( ruth4 ) रूथ का 4-क्रम सहानुभूति समन्वक है ।

विचित्र बात यह है कि, मैं जो भी टाइमस्टेप चुनता हूं, रूथ की 3-ऑर्डर विधि मेरे परीक्षण में रूथ के 4-ऑर्डर विधि की तुलना में अधिक सटीक प्रतीत होती है, यहां तक कि परिमाण के एक क्रम से भी।

मेरा सवाल इसलिए है: मैं यहां क्या गलत कर रहा हूं? नीचे दिए गए विवरण।

विधियां अलग-अलग हैमिल्टन के साथ सिस्टम में अपनी ताकत को प्रकट करती हैं , अर्थात जिन्हें

H (q, p) = T (p) + V (q)

$H(q,p) = T(p) + V(q)$ रूप में लिखा जा सकता है जहां

q

$q$ में सभी स्थिति निर्देशांक शामिल हैं , में संयुग्म क्षण शामिल हैं, गतिज का प्रतिनिधित्व करता है ऊर्जा और संभावित ऊर्जा।

p

$p$

T

$T$

V

$V$

हमारे सेटअप में, हम उन लोगों द्वारा बलों और गति को सामान्य कर सकते हैं जिन्हें वे लागू होते हैं। इस प्रकार बल त्वरण में बदल जाते हैं, और क्षण वेग में बदल जाते हैं।

सहानुभूति इंटीग्रेटर्स विशेष (दिए गए, निरंतर) गुणांक के साथ आते हैं जिन्हें मैं और लेबल । उन गुणांक के साथ, समय-प्रणाली के विकास का एक कदम -समय पर रूप ले लेता है $a_1,\ldots,a_n$ $b_1,\ldots,b_n$ $t$ $t+\delta t$

के लिए : $i=1,\ldots,n$
1. सभी पदों के वेक्टर को देखते हुए सभी त्वरणों की वेक्टर की गणना करें $g$ $q$
2. द्वारा सभी वेगों के वेक्टर को बदलें $v$ $b_i\,g\,\delta t$
3. द्वारा सभी पदों के वेक्टर को बदलें $q$ $a_i\,v\,\delta t$

ज्ञान अब गुणांक में निहित है। ये

\begin{aligned} [\begin{matrix} a_{1} & a_{2} \\ b_{1} & b_{2} \end{matrix}] & = [\begin{matrix} \frac{1}{2} & \frac{1}{2} \\ 0 & 1 \end{matrix}] & (leap2) \\ [\begin{matrix} a_{1} & a_{2} & a_{3} \\ b_{1} & b_{2} & b_{3} \end{matrix}] & = [\begin{matrix} \frac{2}{3} & - \frac{2}{3} & 1 \\ \frac{7}{24} & \frac{3}{4} & - \frac{1}{24} \end{matrix}] & (ruth3) \\ [\begin{matrix} a_{1} & a_{2} & a_{3} & a_{4} \\ b_{1} & b_{2} & b_{3} & b_{4} \end{matrix}] & = \frac{1}{2 - \sqrt[3]{2}} [\begin{matrix} \frac{1}{2} & \frac{1 - \sqrt[3]{2}}{2} & \frac{1 - \sqrt[3]{2}}{2} & \frac{1}{2} \\ 0 & 1 & - \sqrt[3]{2} & 1 \end{matrix}] & (ruth4) \end{aligned}

$\begin{align} \begin{bmatrix} a_1 & a_2 \\ b_1 & b_2 \end{bmatrix} &= \begin{bmatrix} \frac{1}{2} & \frac{1}{2} \\ 0 & 1 \end{bmatrix} &&\textsf{(leap2)} \\ \begin{bmatrix} a_1 & a_2 & a_3 \\ b_1 & b_2 & b_3 \end{bmatrix} &= \begin{bmatrix} \frac{2}{3} & -\frac{2}{3} & 1 \\ \frac{7}{24} & \frac{3}{4} & -\frac{1}{24} \end{bmatrix} &&\textsf{(ruth3)} \\ \begin{bmatrix} a_1 & a_2 & a_3 & a_4 \\ b_1 & b_2 & b_3 & b_4 \end{bmatrix} &= \frac{1}{2-\sqrt[3]{2}} \begin{bmatrix} \frac{1}{2} & \frac{1-\sqrt[3]{2}}{2} & \frac{1-\sqrt[3]{2}}{2} & \frac{1}{2} \\ 0 & 1 & -\sqrt[3]{2} & 1 \end{bmatrix} &&\textsf{(ruth4)} \end{align}$

परीक्षण के लिए, मैंने 1D प्रारंभिक मान समस्या जिसमें एक अलग हैमिल्टन है। यहाँ, की पहचान ।

\begin{aligned} y^{″} + y & = 0 & y (0) & = 1 & y^{'} (0) & = 0 \end{aligned}

$\begin{align} y''+y &= 0 & y(0) &= 1 & y'(0) &= 0 \end{align}$

∴ (y (t), y^{'} (t)) = (\cos t, - \sin t)

$\therefore\quad \left(y(t),y'(t)\right) = (\cos t, -\sin t)$

(q, v)

$(q,v)$

(y, y^{'})

$(y,y')$

मैंने IVP को उपरोक्त विधियों के साथ में के चरणों के साथ एक पूर्णांक साथ कहीं और बीच चुना है । ले रहा है leap2 खाते में की गति, मैं तीन गुना कि विधि के लिए। फिर मैंने चरण स्थान में परिणामी वक्रों को प्लॉट किया और पर ज़ूम इन किया, जहाँ कर्व्स को आदर्श रूप से पर फिर से आना चाहिए । $t\in[0,2\pi]$ $\delta t=\frac{2\pi}{N}$ $N$ $10$ $100$ $N$ $(1,0)$ $t=2\pi$

यहाँ और लिए प्लॉट और ज़ूम हैं : $N=12$ $N=36$

के लिए , leap2 कदम आकार के साथ से घर के करीब आने के लिए होता है ruth4 कदम आकार के साथ । के लिए , ruth4 से अधिक जीत leap2 । हालांकि, ruth3 , के रूप में एक ही कदम आकार के साथ ruth4 , आता है बहुत करीब दोनों दूसरों की तुलना में घर के लिए, सभी सेटिंग्स में मैं अब तक का परीक्षण किया है। $N=12$ $\frac{2\pi}{3N}$ $\frac{2\pi}{N}$ $N=36$

यहाँ पायथन / पायलैब स्क्रिप्ट है:

import numpy as np
import matplotlib.pyplot as plt

def symplectic_integrate_step(qvt0, accel, dt, coeffs):
    q,v,t = qvt0
    for ai,bi in coeffs.T:
        v += bi * accel(q,v,t) * dt
        q += ai * v * dt
        t += ai * dt
    return q,v,t

def symplectic_integrate(qvt0, accel, t, coeffs):
    q = np.empty_like(t)
    v = np.empty_like(t)
    qvt = qvt0
    q[0] = qvt[0]
    v[0] = qvt[1]
    for i in xrange(1, len(t)):
        qvt = symplectic_integrate_step(qvt, accel, t[i]-t[i-1], coeffs)
        q[i] = qvt[0]
        v[i] = qvt[1]
    return q,v

c = np.math.pow(2.0, 1.0/3.0)
ruth4 = np.array([[0.5, 0.5*(1.0-c), 0.5*(1.0-c), 0.5],
                  [0.0,         1.0,          -c, 1.0]]) / (2.0 - c)
ruth3 = np.array([[2.0/3.0, -2.0/3.0, 1.0], [7.0/24.0, 0.75, -1.0/24.0]])
leap2 = np.array([[0.5, 0.5], [0.0, 1.0]])

accel = lambda q,v,t: -q
qvt0 = (1.0, 0.0, 0.0)
tmax = 2.0 * np.math.pi
N = 36

fig, ax = plt.subplots(1, figsize=(6, 6))
ax.axis([-1.3, 1.3, -1.3, 1.3])
ax.set_aspect('equal')
ax.set_title(r"Phase plot $(y(t),y'(t))$")
ax.grid(True)
t = np.linspace(0.0, tmax, 3*N+1)
q,v = symplectic_integrate(qvt0, accel, t, leap2)
ax.plot(q, v, label='leap2 (%d steps)' % (3*N), color='black')
t = np.linspace(0.0, tmax, N+1)
q,v = symplectic_integrate(qvt0, accel, t, ruth3)
ax.plot(q, v, label='ruth3 (%d steps)' % N, color='red')
q,v = symplectic_integrate(qvt0, accel, t, ruth4)
ax.plot(q, v, label='ruth4 (%d steps)' % N, color='blue')
ax.legend(loc='center')
fig.show()

मैंने पहले ही सरल त्रुटियों के लिए जाँच कर ली है:

कोई विकिपीडिया टाइपो नहीं। मैंने संदर्भों की जाँच की है, विशेष रूप से ( 1 , 2 , 3 )।
मुझे गुणांक अनुक्रम सही मिला है। यदि आप विकिपीडिया के आदेश के साथ तुलना करते हैं, तो ध्यान दें कि ऑपरेटर आवेदन की अनुक्रमण दाएं से बाएं ओर काम करता है। मेरी संख्या कैंडी / रोज़्ज़स से सहमत है । और अगर मैं एक और आदेश देने की कोशिश करता हूं, तो परिणाम खराब होते हैं।

मेरा शक:

गलत कदम आदेश: हो सकता है कि रूथ की 3-ऑर्डर स्कीम में किसी तरह से बहुत छोटे निहित स्थिरांक हों, और यदि चरण का आकार वास्तव में छोटा हो, तो 4-क्रम विधि जीत जाएगी? लेकिन मैंने को भी आजमाया है , और तीसरा क्रम अभी भी बेहतर है। $N=360$
गलत परीक्षण: मेरे परीक्षण के बारे में कुछ विशेष रूथ के 3-क्रम विधि को उच्च-क्रम विधि की तरह व्यवहार करने देता है?

python time-integration

— ccorn
स्रोत

क्या आप त्रुटियों के संख्यात्मक मान दे सकते हैं? प्लॉट से बताना थोड़ा मुश्किल है। बदलने के साथ त्रुटियों का पैमाना कैसे होता है ? क्या वे तरीकों के आदेशों से अपेक्षित पैमाने पर हैं? आमतौर पर कोई भी इसे जांचने के लिए लॉग-लॉग प्लॉट पर खिलाफ त्रुटियों की साजिश करेगा ।

N

$N$

N

$N$

— किरील

@Kirill: उस पर काम करना। जल्द ही संपादित करेंगे।

— 19

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

— किरिल

जवाबों:

बाद किरिल के सुझाव, मैं के साथ परीक्षण भागा मोटे तौर पर ज्यामितीय बढ़ती मानों की सूची से, और प्रत्येक के लिए के रूप में त्रुटि गणना की जहां सन्निकटन का प्रतिनिधित्व करता है संख्यात्मक एकीकरण द्वारा प्राप्त किया गया। यहाँ एक लॉग-लॉग प्लॉट में परिणाम है: $N$ $N$

ϵ (N) = ‖ \tilde{z} (2 π) - \tilde{z} (0) ‖_{2} where \tilde{z} (t) = (\tilde{y} (t), {\tilde{y}}^{'} (t))

$\epsilon(N) = \|\tilde z(2\pi) - \tilde z(0)\|_2 \quad\text{where}\quad \tilde z(t) = \left(\tilde{y}(t),\tilde y'(t)\right)$

\tilde{z}

$\tilde z$

तो ruth3 वास्तव में एक ही आदेश है के रूप में ruth4 कि परीक्षण मामले के लिए और केवल निहित स्थिरांक परिमाण। $4$ $\frac{1}{100}$

दिलचस्प। मुझे आगे की जांच करनी होगी, शायद अन्य परीक्षणों की कोशिश करना।

वैसे, यहाँ त्रुटि प्लॉट के लिए पायथन लिपि के अतिरिक्त हैं:

def int_error(qvt0, accel, qvt1, Ns, coeffs):
    e = np.empty((len(Ns),))
    for i,N in enumerate(Ns):
        t = np.linspace(qvt0[2], qvt1[2], N+1)
        q,v = symplectic_integrate(qvt0, accel, t, coeffs)
        e[i] = np.math.sqrt((q[-1]-qvt1[0])**2+(v[-1]-qvt1[1])**2)
    return e

qvt1 = (1.0, 0.0, tmax)
Ns = [12,16,20,24,32,40,48,64,80,96,128,160,192,
      256,320,384,512,640,768,1024,1280,1536,2048,2560,3072]

fig, ax = plt.subplots(1)
ax.set_xscale('log')
ax.set_xlabel(r"$N$")
ax.set_yscale('log')
ax.set_ylabel(r"$\|z(2\pi)-z(0)\|$")
ax.set_title(r"Error after 1 period vs #steps")
ax.grid(True)
e = int_error(qvt0, accel, qvt1, Ns, leap2)
ax.plot(Ns, e, label='leap2', color='black')
e = int_error(qvt0, accel, qvt1, Ns, ruth3)
ax.plot(Ns, e, label='ruth3', color='red')
e = int_error(qvt0, accel, qvt1, Ns, ruth4)
ax.plot(Ns, e, label='ruth4', color='blue')
ax.legend(loc='upper right')
fig.show()

— ccorn
स्रोत

प्रश्न के लिए प्रासंगिक नहीं है, लेकिन क्या आप अलग-अलग उत्तर के रूप में पोस्ट करने के बजाय, स्वयं में परिवर्तन और अपडेट डाल सकते हैं? यह प्रथा उस अधिवेशन को बनाए रखती है जिसमें सवालों के जवाब देने चाहिए ।

— किरिल

@Kirill: यह है एक जवाब। ruth3 का वास्तव में उच्च क्रम और कम स्थिरांक है। लॉग-लॉग त्रुटि प्लॉट बनाने के आपके सुझाव के कारण खोजा गया। इसलिए प्रश्न का उत्तर दिया जाता है, और मैं निश्चित रूप से एक प्रश्न के उत्तर को एक बार बदल दूंगा, जिसका उत्तर दिया गया है, न कि मेरे द्वारा उत्तर दिए जाने पर भी।

— 21

उस ने कहा, मुझे आगे के विश्लेषण को स्वीकार करने में खुशी होगी। (स्व-

— उत्तरित

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

p_{0} \neq 0

$p_0\neq0$

V (q) = 1 / q + \log q

$V(q)=1/q+\log q$

V

$V$

— किरिल

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

— क्रिस रैकॉकास

अपेक्षित क्रम से दिए गए स्टेप साइज की शक्ति द्वारा स्केल किए गए पूर्ण अंतराल पर , की त्रुटि को प्लॉट कर देता है। $\ddot q=-q$ $q(0)=1,\dot q(0)=0$

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

तीसरी क्रम रूथ विधि में, घटक का प्रमुख गुणांक शून्य प्रतीत होता है, दृश्यमान सीमा वक्र क्षैतिज अक्ष के करीब या बराबर है। दृश्यमान रेखांकन स्पष्ट रूप से 4 वें क्रम त्रुटि शब्द के प्रभुत्व को दर्शाता है। 4 वें क्रम की त्रुटि के लिए स्केलिंग दूसरों के समान एक भूखंड देता है। $p$

जैसा कि कोई भी देख सकता है, सभी 3 मामलों में एक पूर्ण अवधि के बाद घटक में अग्रणी क्रम का त्रुटि गुणांक पर शून्य है । दोनों घटकों की त्रुटियों के संयोजन में, घटक का व्यवहार इस प्रकार हावी होता है, गलत तरीके से लॉगलॉग प्लॉट में एक 4 वें क्रम विधि की छाप देता है। $q$ $t=2\pi$ $p$

घटक में एक अधिकतम गुणांक आसपास पाया जा सकता है । वहाँ लॉग लॉग प्लॉट सही वैश्विक त्रुटि आदेश को प्रतिबिंबित करना चाहिए। $q$ $3\pi/2$

Ruth3p में 3 डिग्री त्रुटि शब्द का गायब होना रेखीय समीकरण की सादगी का एक गुण है जो गैर-रेखीय उदाहरण , संबंधित भूखंडों के साथ $\ddot q=-\sin(q)$ $q(0)=1.3,~\dot q(0)=0$

— लुत्ज लेहमन
स्रोत