File size: 10,091 Bytes
cc9df09
47fe089
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
cc9df09
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
import numpy as np

class MidPoint():

    def __init__(self, j):
        self.j = j

    def initial(self):
        j = self.j

        #init parameters
        h, b, n, u = 0.1, None, None, None
        x, y, z, px, py, pz = None, 0.1, 0.001, 0.01, None, 0.0001
        xa, ya, za, pxa, pya, pza = None, None, None, None, None, None

        if j == 1:
            b = 5.0 / 4
            n = b / (1 + b) ** 2
            u = 1.0 / (1.0 / b + b + 2.0)
            x = 10.0
            py = 0.5
        elif j == 2:
            b = 3.0 / 4
            n = b / (1 + b) ** 2
            u = 1.0 / (1.0 / b + b + 2.0)
            x = 8.3
            py = 0.6
        elif j == 3:
            b = 3.0 / 2
            x = 12.0
            py = 0.4
        elif j == 4:
            b = 7.0 / 4
            n = b / (1 + b) ** 2
            u = 1.0 / (1.0 / b + b + 2.0)
            x = 15.0
            py = 0.35
        elif j == 5:
            b = 1.0
            n = b / (1 + b) ** 2
            u = 1.0 / (1.0 / b + b + 2.0)
            x = 18.0
            py = 0.3
        elif j == 6:
            b = 3.0 / 5
            n = b / (1 + b) ** 2
            u = 1.0 / (1.0 / b + b + 2.0)
            x = 20.0
            py = 0.25
        elif j == 7:
            b = 5.0 / 7
            n = b / (1 + b) ** 2
            u = 1.0 / (1.0 / b + b + 2.0)
            x = 22.0
            py = 0.22
        elif j == 8:
            b = 2.0
            x = 26.0
            py = 0.2
        elif j == 9:
            b = 0.5
            n = b / (1 + b) ** 2
            u = 1.0 / (1.0 / b + b + 2.0)
            x = 30.0
            y = 0.5
            z = 0.1
            pz = 0.01
        elif j == 10:
            b = 5.0
            n = b / (1 + b) ** 2
            u = 1.0 / (1.0 / b + b + 2.0)
            x = 35.0
            y = 2.0
            z = 0.1
            pz = 0.03
            py = 0.15

        xa, ya, za, pxa, pya, pza = x, y, z, px, py, pz
        return j, h, b, n, x, y, z, xa, ya, za, px, py, pz, pxa, pya, pza

    def f(self, x, y, z, px, py, pz, b):

        n = b / (1 + b) ** 2
        u = 1 / (1 / b + b + 2)
        ht = px ** 2 / 2 + py ** 2 / 2 + pz ** 2 / 2
        hv = -1 / (x ** 2 + y ** 2 + z ** 2) ** (1 / 2)
        h1pn = 1 / (2 * x ** 2 + 2 * y ** 2 + 2 * z ** 2) - (((u + 3) * (px ** 2 + py ** 2 + pz ** 2)) / 2 + (u * (
                    (px * x) / (x ** 2 + y ** 2 + z ** 2) ** (1 / 2) + (py * y) / (x ** 2 + y ** 2 + z ** 2) ** (
                        1 / 2) + (pz * z) / (x ** 2 + y ** 2 + z ** 2) ** (1 / 2)) ** 2) / 2) / (
                           x ** 2 + y ** 2 + z ** 2) ** (1 / 2) + ((3 * u) / 8 - 1 / 8) * (
                           px ** 2 + py ** 2 + pz ** 2) ** 2

        e = ht + hv + h1pn

        vnpx = px
        v1pnpx = 4 * px * ((3 * n) / 8 - 1 / 8) * (px ** 2 + py ** 2 + pz ** 2) - (px * (n + 3) + (n * x * (
                    (px * x) / (x ** 2 + y ** 2 + z ** 2) ** (1 / 2) + (py * y) / (x ** 2 + y ** 2 + z ** 2) ** (
                        1 / 2) + (pz * z) / (x ** 2 + y ** 2 + z ** 2) ** (1 / 2))) / (x ** 2 + y ** 2 + z ** 2) ** (
                                                                                               1 / 2)) / (
                             x ** 2 + y ** 2 + z ** 2) ** (1 / 2)
        vpx = vnpx + v1pnpx

        vnpy = py
        v1pnpy = 4 * py * ((3 * n) / 8 - 1 / 8) * (px ** 2 + py ** 2 + pz ** 2) - (py * (n + 3) + (n * y * (
                    (px * x) / (x ** 2 + y ** 2 + z ** 2) ** (1 / 2) + (py * y) / (x ** 2 + y ** 2 + z ** 2) ** (
                        1 / 2) + (pz * z) / (x ** 2 + y ** 2 + z ** 2) ** (1 / 2))) / (x ** 2 + y ** 2 + z ** 2) ** (
                                                                                               1 / 2)) / (
                             x ** 2 + y ** 2 + z ** 2) ** (1 / 2)
        vpy = vnpy + v1pnpy

        vnpz = pz
        v1pnpz = 4 * pz * ((3 * n) / 8 - 1 / 8) * (px ** 2 + py ** 2 + pz ** 2) - (pz * (n + 3) + (n * z * (
                    (px * x) / (x ** 2 + y ** 2 + z ** 2) ** (1 / 2) + (py * y) / (x ** 2 + y ** 2 + z ** 2) ** (
                        1 / 2) + (pz * z) / (x ** 2 + y ** 2 + z ** 2) ** (1 / 2))) / (x ** 2 + y ** 2 + z ** 2) ** (
                                                                                               1 / 2)) / (
                             x ** 2 + y ** 2 + z ** 2) ** (1 / 2)
        vpz = vnpz + v1pnpz

        vnx = x / (x ** 2 + y ** 2 + z ** 2) ** (3 / 2)
        v1pnx = (x * ((n * (
                    (px * x) / (x ** 2 + y ** 2 + z ** 2) ** (1 / 2) + (py * y) / (x ** 2 + y ** 2 + z ** 2) ** (
                        1 / 2) + (pz * z) / (x ** 2 + y ** 2 + z ** 2) ** (1 / 2)) ** 2) / 2 + (
                                  (n + 3) * (px ** 2 + py ** 2 + pz ** 2)) / 2)) / (x ** 2 + y ** 2 + z ** 2) ** (
                            3 / 2) - (4 * x) / (2 * x ** 2 + 2 * y ** 2 + 2 * z ** 2) ** 2 + (n * (
                    (px * x) / (x ** 2 + y ** 2 + z ** 2) ** (1 / 2) + (py * y) / (x ** 2 + y ** 2 + z ** 2) ** (
                        1 / 2) + (pz * z) / (x ** 2 + y ** 2 + z ** 2) ** (1 / 2)) * ((px * x ** 2) / (
                    x ** 2 + y ** 2 + z ** 2) ** (3 / 2) - px / (x ** 2 + y ** 2 + z ** 2) ** (1 / 2) + (py * x * y) / (
                                                                                                  x ** 2 + y ** 2 + z ** 2) ** (
                                                                                                  3 / 2) + (
                                                                                                  pz * x * z) / (
                                                                                                  x ** 2 + y ** 2 + z ** 2) ** (
                                                                                                  3 / 2))) / (
                            x ** 2 + y ** 2 + z ** 2) ** (1 / 2)
        vx = vnx + v1pnx

        vny = y / (x ** 2 + y ** 2 + z ** 2) ** (3 / 2)
        v1pny = (y * ((n * (
                    (px * x) / (x ** 2 + y ** 2 + z ** 2) ** (1 / 2) + (py * y) / (x ** 2 + y ** 2 + z ** 2) ** (
                        1 / 2) + (pz * z) / (x ** 2 + y ** 2 + z ** 2) ** (1 / 2)) ** 2) / 2 + (
                                  (n + 3) * (px ** 2 + py ** 2 + pz ** 2)) / 2)) / (x ** 2 + y ** 2 + z ** 2) ** (
                            3 / 2) - (4 * y) / (2 * x ** 2 + 2 * y ** 2 + 2 * z ** 2) ** 2 + (n * (
                    (px * x) / (x ** 2 + y ** 2 + z ** 2) ** (1 / 2) + (py * y) / (x ** 2 + y ** 2 + z ** 2) ** (
                        1 / 2) + (pz * z) / (x ** 2 + y ** 2 + z ** 2) ** (1 / 2)) * ((py * y ** 2) / (
                    x ** 2 + y ** 2 + z ** 2) ** (3 / 2) - py / (x ** 2 + y ** 2 + z ** 2) ** (1 / 2) + (px * x * y) / (
                                                                                                  x ** 2 + y ** 2 + z ** 2) ** (
                                                                                                  3 / 2) + (
                                                                                                  pz * y * z) / (
                                                                                                  x ** 2 + y ** 2 + z ** 2) ** (
                                                                                                  3 / 2))) / (
                            x ** 2 + y ** 2 + z ** 2) ** (1 / 2)
        vy = vny + v1pny

        vnz = z / (x ** 2 + y ** 2 + z ** 2) ** (3 / 2)
        v1pnz = (z * ((n * (
                    (px * x) / (x ** 2 + y ** 2 + z ** 2) ** (1 / 2) + (py * y) / (x ** 2 + y ** 2 + z ** 2) ** (
                        1 / 2) + (pz * z) / (x ** 2 + y ** 2 + z ** 2) ** (1 / 2)) ** 2) / 2 + (
                                  (n + 3) * (px ** 2 + py ** 2 + pz ** 2)) / 2)) / (x ** 2 + y ** 2 + z ** 2) ** (
                            3 / 2) - (4 * z) / (2 * x ** 2 + 2 * y ** 2 + 2 * z ** 2) ** 2 + (n * (
                    (px * x) / (x ** 2 + y ** 2 + z ** 2) ** (1 / 2) + (py * y) / (x ** 2 + y ** 2 + z ** 2) ** (
                        1 / 2) + (pz * z) / (x ** 2 + y ** 2 + z ** 2) ** (1 / 2)) * ((pz * z ** 2) / (
                    x ** 2 + y ** 2 + z ** 2) ** (3 / 2) - pz / (x ** 2 + y ** 2 + z ** 2) ** (1 / 2) + (px * x * z) / (
                                                                                                  x ** 2 + y ** 2 + z ** 2) ** (
                                                                                                  3 / 2) + (
                                                                                                  py * y * z) / (
                                                                                                  x ** 2 + y ** 2 + z ** 2) ** (
                                                                                                  3 / 2))) / (
                            x ** 2 + y ** 2 + z ** 2) ** (1 / 2)
        vz = vnz + v1pnz
        return vx, vy, vz, vpx, vpy, vpz, e

    def implecitsymplectic(self, h, x, y, z, px, py, pz, b):

        x1 = x
        y1 = y
        z1 = z
        px1 = px
        py1 = py
        pz1 = pz
        num = 0
        d = 1.1
        while (d > 1e-16 and num < 1000):
            px2 = px
            py2 = py
            pz2 = pz
            x2 = x
            y2 = y
            z2 = z
            x = (x1 + x) / 2
            y = (y1 + y) / 2
            z = (z1 + z) / 2
            px = (px1 + px) / 2
            py = (py1 + py) / 2
            pz = (pz1 + pz) / 2
            vx, vy, vz, vpx, vpy, vpz, e = self.f(x, y, z, px, py, pz, b)
            x = x1 + h * vpx
            y = y1 + h * vpy
            z = z1 + h * vpz
            px = px1 - h * vx
            py = py1 - h * vy
            pz = pz1 - h * vz
            d = np.sqrt(np.abs(x - x2) + np.abs(y - y2) + np.abs(z - z2) + np.abs(px - px2) + np.abs(py - py2) + np.abs(
                pz - pz2))
            num += 1
            #print(num, d)
        return x, y, z, px, py, pz