numba_kernels.py ダウンロード/コピー

numba_kernels.py をダウンロード

numba_kernels.py
numba_kernels.py
  1"""
  2概要:
  3    Numbaを用いてJITコンパイルされたN体シミュレーション用のカーネル関数モジュールです。
  4詳細説明:
  5    並列処理の有効無効を環境変数 PLANET_NUMBA_PARALLEL により切り替え、
  6    各粒子の加速度計算、エネルギー計算、各種積分法のステップ処理を高速に実行します。
  7関連リンク:
  8    benchmark_common
  9"""
 10
 11import os
 12import numpy as np
 13from numba import njit, prange
 14from benchmark_common import G1
 15PARALLEL = os.environ.get("PLANET_NUMBA_PARALLEL", "0") == "1"
 16
 17@njit(parallel=PARALLEL, cache=True)
 18def pairwise_accel_inplace_jit(m, r, a_out):
 19    """
 20    概要:
 21        a_out に加速度を書き込むインプレース版関数です。
 22    詳細説明:
 23        r2が0の際は寄与をスキップしてゼロ割を回避します。ウォームアップ等の安全策として機能します。
 24    引数:
 25        :param m: 質量配列。
 26        :type m: numpy.ndarray
 27        :param r: 位置配列。
 28        :type r: numpy.ndarray
 29        :param a_out: 加速度を出力する配列。
 30        :type a_out: numpy.ndarray
 31    戻り値:
 32        :returns: なし。
 33        :rtype: None
 34    """
 35    N = r.shape[0]
 36    for i in prange(N):
 37        xi = r[i,0]; yi = r[i,1]; zi = r[i,2]
 38        ax = 0.0; ay = 0.0; az = 0.0
 39        for j in range(N):
 40            if i == j:
 41                continue
 42            dx = r[j,0]-xi; dy = r[j,1]-yi; dz = r[j,2]-zi
 43            r2 = dx*dx + dy*dy + dz*dz
 44            if r2 == 0.0:
 45                continue
 46            invr  = 1.0 / np.sqrt(r2)
 47            invr3 = invr * invr * invr
 48            s = G1 * m[j] * invr3
 49            ax += s*dx; ay += s*dy; az += s*dz
 50        a_out[i,0] = ax; a_out[i,1] = ay; a_out[i,2] = az
 51
 52@njit(cache=True)
 53def potential_energy_jit(m, r):
 54    """
 55    概要:
 56        系のポテンシャルエネルギーを計算します。
 57    引数:
 58        :param m: 質量配列。
 59        :type m: numpy.ndarray
 60        :param r: 位置配列。
 61        :type r: numpy.ndarray
 62    戻り値:
 63        :returns: ポテンシャルエネルギー。
 64        :rtype: float
 65    """
 66    N = r.shape[0]
 67    U = 0.0
 68    for i in range(N):
 69        xi = r[i,0]; yi = r[i,1]; zi = r[i,2]
 70        mi = m[i]
 71        for j in range(i+1, N):
 72            dx = r[j,0]-xi; dy = r[j,1]-yi; dz = r[j,2]-zi
 73            dist = np.sqrt(dx*dx + dy*dy + dz*dz)
 74            U += G1 * mi * m[j] / dist
 75    return U
 76
 77@njit(cache=True)
 78def kinetic_energy_jit(m, v):
 79    """
 80    概要:
 81        系の運動エネルギーを計算します。
 82    引数:
 83        :param m: 質量配列。
 84        :type m: numpy.ndarray
 85        :param v: 速度配列。
 86        :type v: numpy.ndarray
 87    戻り値:
 88        :returns: 運動エネルギー。
 89        :rtype: float
 90    """
 91    K = 0.0
 92    for i in range(m.shape[0]):
 93        vi2 = v[i,0]*v[i,0] + v[i,1]*v[i,1] + v[i,2]*v[i,2]
 94        K += 0.5 * m[i] * vi2
 95    return K
 96
 97@njit(cache=True)
 98def momentum_jit(m, v):
 99    """
100    概要:
101        系の総運動量と、スケーリングされた運動量ノルムを計算します。
102    引数:
103        :param m: 質量配列。
104        :type m: numpy.ndarray
105        :param v: 速度配列。
106        :type v: numpy.ndarray
107    戻り値:
108        :returns: x方向、y方向、z方向の総運動量と、スケーリングされた運動量ノルムのタプル。
109        :rtype: tuple
110    """
111    Px=0.0; Py=0.0; Pz=0.0
112    for i in range(m.shape[0]):
113        mi = m[i]
114        Px += mi*v[i,0]; Py += mi*v[i,1]; Pz += mi*v[i,2]
115    P2 = Px*Px + Py*Py + Pz*Pz
116    Pmsm = np.sqrt(P2/(3.0*max(1, m.shape[0])))
117    return Px, Py, Pz, Pmsm
118
119@njit(cache=True)
120def normalize_momentum_jit(m, v):
121    """
122    概要:
123        重心の運動量がゼロになるように各粒子の速度を正規化します。
124    引数:
125        :param m: 質量配列。
126        :type m: numpy.ndarray
127        :param v: 速度配列。インプレースで更新されます。
128        :type v: numpy.ndarray
129    戻り値:
130        :returns: なし。
131        :rtype: None
132    """
133    Px=0.0; Py=0.0; Pz=0.0
134    Mtot = 0.0
135    for i in range(m.shape[0]):
136        mi = m[i]; Mtot += mi
137        Px += mi*v[i,0]; Py += mi*v[i,1]; Pz += mi*v[i,2]
138    for i in range(m.shape[0]):
139        v[i,0] -= Px/Mtot
140        v[i,1] -= Py/Mtot
141        v[i,2] -= Pz/Mtot
142
143# --- JIT steppers: advance K steps in-place ---
144@njit(cache=True)
145def step_euler_k_jit(m, r, v, a, dt, k_steps):
146    """
147    概要:
148        オイラー法を用いて、インプレースで複数ステップ分の時間積分を行います。
149    引数:
150        :param m: 質量配列。
151        :type m: numpy.ndarray
152        :param r: 位置配列。
153        :type r: numpy.ndarray
154        :param v: 速度配列。
155        :type v: numpy.ndarray
156        :param a: 加速度配列。
157        :type a: numpy.ndarray
158        :param dt: タイムステップ幅。
159        :type dt: float
160        :param k_steps: 積分を行うステップ数。
161        :type k_steps: int
162    戻り値:
163        :returns: 更新された加速度配列。
164        :rtype: numpy.ndarray
165    """
166    for _ in range(k_steps):
167        v[:,0] += dt*a[:,0]; v[:,1] += dt*a[:,1]; v[:,2] += dt*a[:,2]
168        r[:,0] += dt*v[:,0]; r[:,1] += dt*v[:,1]; r[:,2] += dt*v[:,2]
169        pairwise_accel_inplace_jit(m, r, a)
170    return a
171
172@njit(cache=True)
173def step_verlet_k_jit(m, r_prev, r, v, a, dt, k_steps):
174    """
175    概要:
176        ベルレ法を用いて、インプレースで複数ステップ分の時間積分を行います。
177    詳細説明:
178        r_prev、r、v、aはインプレースで更新され、速度vは位置の変化から推定されます。
179    引数:
180        :param m: 質量配列。
181        :type m: numpy.ndarray
182        :param r_prev: 前ステップの位置配列。
183        :type r_prev: numpy.ndarray
184        :param r: 現在の位置配列。
185        :type r: numpy.ndarray
186        :param v: 速度配列。
187        :type v: numpy.ndarray
188        :param a: 加速度配列。
189        :type a: numpy.ndarray
190        :param dt: タイムステップ幅。
191        :type dt: float
192        :param k_steps: 積分を行うステップ数。
193        :type k_steps: int
194    戻り値:
195        :returns: 更新された加速度配列。
196        :rtype: numpy.ndarray
197    """
198    # r_prev, r, v, a updated in-place; v is estimated from positions
199    for _ in range(k_steps):
200        r_new_x = 2.0*r[:,0] - r_prev[:,0] + (dt*dt)*a[:,0]
201        r_new_y = 2.0*r[:,1] - r_prev[:,1] + (dt*dt)*a[:,1]
202        r_new_z = 2.0*r[:,2] - r_prev[:,2] + (dt*dt)*a[:,2]
203        v[:,0] = (r_new_x - r_prev[:,0])/(2.0*dt)
204        v[:,1] = (r_new_y - r_prev[:,1])/(2.0*dt)
205        v[:,2] = (r_new_z - r_prev[:,2])/(2.0*dt)
206        r_prev[:,0], r[:,0] = r[:,0], r_new_x
207        r_prev[:,1], r[:,1] = r[:,1], r_new_y
208        r_prev[:,2], r[:,2] = r[:,2], r_new_z
209        pairwise_accel_inplace_jit(m, r, a)
210    return a
211
212@njit(cache=True)
213def step_vverlet_k_jit(m, r, v, a, dt, k_steps):
214    """
215    概要:
216        速度ベルレ法を用いて、インプレースで複数ステップ分の時間積分を行います。
217    引数:
218        :param m: 質量配列。
219        :type m: numpy.ndarray
220        :param r: 位置配列。
221        :type r: numpy.ndarray
222        :param v: 速度配列。
223        :type v: numpy.ndarray
224        :param a: 加速度配列。
225        :type a: numpy.ndarray
226        :param dt: タイムステップ幅。
227        :type dt: float
228        :param k_steps: 積分を行うステップ数。
229        :type k_steps: int
230    戻り値:
231        :returns: 更新された加速度配列。
232        :rtype: numpy.ndarray
233    """
234    for _ in range(k_steps):
235        v[:,0] += 0.5*dt*a[:,0]; v[:,1] += 0.5*dt*a[:,1]; v[:,2] += 0.5*dt*a[:,2]
236        r[:,0] += dt*v[:,0];     r[:,1] += dt*v[:,1];     r[:,2] += dt*v[:,2]
237        pairwise_accel_inplace_jit(m, r, a)
238        v[:,0] += 0.5*dt*a[:,0]; v[:,1] += 0.5*dt*a[:,1]; v[:,2] += 0.5*dt*a[:,2]
239    return a