Thử nghiệm tích hợp đối xứng bậc 3 so với bậc 4 với kết quả lạ

Trong câu trả lời của tôi cho một câu hỏi về MSE liên quan đến mô phỏng vật lý 2D Hamilton, tôi đã đề nghị sử dụng một bộ tích hợp đối xứng bậc cao .

Sau đó, tôi nghĩ rằng có thể là một ý tưởng tốt để chứng minh tác động của các bước thời gian khác nhau đối với độ chính xác toàn cầu của các phương thức với các đơn đặt hàng khác nhau, và tôi đã viết và chạy một kịch bản Python / Pylab cho hiệu ứng đó. Để so sánh tôi đã chọn:

• ( leap2 ) Ví dụ thứ 2 của Wikipedia mà tôi quen thuộc, mặc dù tôi biết nó dưới tên leapfrog ,
• ( ruth3 ) Nhà tích hợp đối xứng bậc 3 của Ruth ,
• ( ruth4 ) Nhà tích hợp đối xứng bậc 4 của Ruth .

Điều kỳ lạ là, bất kể dấu thời gian nào tôi chọn, phương pháp bậc 3 của Ruth dường như chính xác hơn trong thử nghiệm của tôi so với phương pháp bậc 4 của Ruth, thậm chí theo một độ lớn.

Do đó, câu hỏi của tôi là: Tôi đang làm gì sai ở đây? Chi tiết bên dưới.

Các phương thức mở ra sức mạnh của chúng trong các hệ thống với người Hamilton có thể tách rời , tức là những phương pháp có thể được viết là trong đó bao gồm tất cả các tọa độ vị trí, bao gồm mô men liên hợp, đại diện cho động học năng lượng và năng lượng tiềm năng

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

Trong thiết lập của chúng tôi, chúng tôi có thể bình thường hóa lực lượng và mô men theo số lượng mà chúng được áp dụng. Do đó, các lực biến thành gia tốc, và mô men biến thành vận tốc.

Các tích hợp symplectic đi kèm với các hệ số đặc biệt (đã cho, không đổi) mà tôi sẽ gắn nhãn và . Với các hệ số đó, một bước để phát triển hệ thống theo thời gian đến thời điểm có dạng$a_1,\ldots,a_n$$b_1,\ldots,b_n$$t$$t+\delta t$

• Với :$i=1,\ldots,n$

  1. Tính vectơ của tất cả các gia tốc, cho vectơ của tất cả các vị trí$g$$q$
  2. Thay đổi vectơ của tất cả các vận tốc bằng$v$$b_i\,g\,\delta t$
  3. Thay đổi vectơ của tất cả các vị trí theo$q$$a_i\,v\,\delta t$

Sự khôn ngoan bây giờ nằm ​​ở các hệ số. Đây là

$$\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}$$

Để thử nghiệm, tôi đã chọn bài toán giá trị ban đầu 1D có Hamiltonian tách rời. Ở đây, được xác định bằng .

$$\begin{align} y''+y &= 0 & y(0) &= 1 & y'(0) &= 0 \end{align}$$ $$\therefore\quad \left(y(t),y'(t)\right) = (\cos t, -\sin t)$$ $(q,v)$$(y,y')$

Tôi đã tích hợp IVP với các phương thức trên qua với một bước là với số nguyên được chọn ở đâu đó trong khoảng từ đến . Lấy leap2 tốc độ của vào tài khoản, tôi gấp ba cho phương pháp đó. Sau đó, tôi đã vẽ các đường cong kết quả trong không gian pha và phóng to ở trong đó các đường cong sẽ lý tưởng trở lại tại .$t\in[0,2\pi]$$\delta t=\frac{2\pi}{N}$$N$$10$$100$N(1,0)t=2π$N$$(1,0)$$t=2\pi$

Dưới đây là các ô và thu phóng cho và :$N=12$$N=36$

Với , leap2 với kích thước bước tình cờ đến gần nhà hơn ruth4 với kích thước bước . Với , ruth4 thắng leap2 . Tuy nhiên, ruth3 , với cùng kích thước bước với ruth4 , đến gần nhà hơn nhiều so với cả hai loại khác, trong tất cả các cài đặt tôi đã thử nghiệm cho đến nay.$N=12$2 π$\frac{2\pi}{3N}$ 2π$\frac{2\pi}{N}$$N=36$

Đây là kịch bản Python / Pylab:

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()

Tôi đã kiểm tra các lỗi đơn giản rồi:

• Không có lỗi đánh máy Wikipedia. Tôi đã kiểm tra các tài liệu tham khảo, đặc biệt ( 1 , 2 , 3 ).
• Tôi đã có trình tự hệ số đúng. Nếu bạn so sánh với thứ tự của Wikipedia, lưu ý rằng trình tự ứng dụng toán tử hoạt động từ phải sang trái. Đánh số của tôi đồng ý với Candy / Rozmus . Và nếu tôi thử đặt hàng khác, kết quả sẽ tệ hơn.

Những nghi ngờ của tôi:

• Thứ tự bước sai: Có thể sơ đồ bậc 3 của Ruth có các hàm ngụ ý nhỏ hơn nhiều và nếu kích thước bước được thực hiện rất nhỏ, thì phương thức bậc 4 sẽ thắng? Nhưng tôi thậm chí đã thử , và phương pháp bậc 3 vẫn vượt trội.$N=360$
• Thử nghiệm sai: Điều gì đó đặc biệt về thử nghiệm của tôi cho phép phương thức bậc 3 của Ruth hoạt động như một phương pháp bậc cao hơn?

Theo đề nghị của Kirill , tôi đã chạy thử nghiệm với từ danh sách các giá trị tăng dần về mặt hình học và với mỗi tính toán lỗi là trong đó đại diện cho xấp xỉ thu được bằng tích phân số. Đây là kết quả trong một biểu đồ log-log:N ε ( N ) = ‖ ~ z ( 2 π ) - ~ $N$$N$

$$\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$

Vì vậy, ruth3 thực sự có cùng thứ tự với ruth4 cho trường hợp thử nghiệm đó và ngụ ý các hằng số chỉ có độ lớn.$4$$\frac{1}{100}$

Hấp dẫn. Tôi sẽ phải điều tra thêm, có lẽ thử các xét nghiệm khác.

Nhân tiện, đây là những bổ sung cho tập lệnh Python cho biểu đồ lỗi:

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()

Vẽ lỗi của , trong toàn bộ khoảng thời gian, được chia tỷ lệ theo sức mạnh của kích thước bước được đưa ra theo thứ tự dự kiến, đưa ra các sơ đồ$\ddot q=-q$$q(0)=1,\dot q(0)=0$

Như mong đợi, các biểu đồ để tăng số lượng các khoảng phụ ngày càng tiếp cận một đường cong giới hạn là hệ số lỗi hàng đầu. Trong tất cả, ngoại trừ một âm mưu, sự hội tụ này rất nhanh, hầu như không có sự phân kỳ. Điều này có nghĩa là ngay cả đối với các kích thước bước tương đối lớn, thuật ngữ lỗi hàng đầu chi phối tất cả các điều khoản khác.

Trong phương pháp Ruth bậc 3, hệ số dẫn đầu của thành phần dường như bằng 0, đường cong giới hạn nhìn thấy gần hoặc bằng trục hoành. Các biểu đồ hiển thị rõ ràng cho thấy sự thống trị của thuật ngữ lỗi thứ 4. Chia tỷ lệ cho lỗi thứ 4 cho một âm mưu tương tự như các lỗi khác.$p$

Như mọi người có thể thấy, trong cả 3 trường hợp, hệ số lỗi của thứ tự hàng đầu trong thành phần là 0 tại sau một khoảng thời gian đầy đủ. Do đó, khi kết hợp các lỗi của cả hai thành phần, hành vi của thành phần sẽ chiếm ưu thế, làm sai lệch ấn tượng của phương thức bậc 4 trong biểu đồ loglog.$q$$t=2\pi$$p$

Một hệ số tối đa trong thành phần có thể được tìm thấy khoảng . Biểu đồ loglog ở đó sẽ phản ánh đúng các đơn đặt hàng lỗi toàn cầu.$q$$3\pi/2$

---

Việc biến mất của thuật ngữ lỗi độ 3 trong Ruth3p là một bằng chứng về sự đơn giản của phương trình tuyến tính cho thấy ví dụ phi tuyến tính , với các ô tương ứng$\ddot q=-\sin(q)$$q(0)=1.3,~\dot q(0)=0$