Question

我目前在10,000个时间点的n体系统中有一个速度列表。它是一个三维数组，涉及三个空间维度中 t 点的 n 粒子。例如，在两个时间点有三个粒子，它被设置为

[[[vx1][vy1][vz1]
  [vx2][vy2][vz2]
  [vx3][vy3][vz3]]
 [[vx1][vy1][vz1]
  [vx2][vy2][vz2]
  [vx3][vy3][vz3]]]

我的最终目标是拥有一个这样的数组：

[[[speed1]
  [speed2]
  [speed3]]
 [[speed1]
  [speed2]
  [speed3]]]

但是，当粒子的数量可以自由变化时，我不能使速度分量以二次方式添加。我可以用这样的两个粒子做到这一点：

# Takes all velocities and converts them to speeds
all_speeds=[]
for i in range(len(all_velocities)):
    all_speeds.append([math.sqrt(all_velocities[i][0][0]**2\
        +all_velocities[i][0][1]**2+all_velocities[i][0][2]**2)],\
            [math.sqrt(all_velocities[i][1][0]**2+all_velocities[i][1][1]**2\
                +all_velocities[i][1][2]**2)])

但我不确定如何将其扩展到 n 粒子。我的最终目标是对速度阵列进行平方，然后将其乘以我必须计算系统动能的质量数组，但我无法将其扩展为任何输入。感谢。

Answer 1

import numpy as np
v1 = [[[1,1,1],
       [2,2,2],
       [3,3,3],
       [4,4,4]],
      [[1,1,1],
       [2,2,2],
       [3,3,3],
       [4,4,4]]]

a = np.array(v1)

a.shape是（t，n，d）。你想要三维速度的平方和的平方根：

>>> a
array([[[1, 1, 1],
        [2, 2, 2],
        [3, 3, 3],
        [4, 4, 4]],

       [[1, 1, 1],
        [2, 2, 2],
        [3, 3, 3],
        [4, 4, 4]]])
>>> #square each velocity
>>> b = np.square(a)
>>> b
array([[[ 1,  1,  1],
        [ 4,  4,  4],
        [ 9,  9,  9],
        [16, 16, 16]],

       [[ 1,  1,  1],
        [ 4,  4,  4],
        [ 9,  9,  9],
        [16, 16, 16]]])
>>> #sum along the dimensions
>>> b = b.sum(axis = 2)
>>> b
array([[ 3, 12, 27, 48],
       [ 3, 12, 27, 48]])
>>> # root of each sum
>>> b = np.sqrt(b)
>>> b
array([[ 1.73205081,  3.46410162,  5.19615242,  6.92820323],
       [ 1.73205081,  3.46410162,  5.19615242,  6.92820323]])
>>>

b.shape是（t，n）。看起来我的数据集中没有任何粒子在加速。

或者简单地说：

>>> np.linalg.norm(a, axis = 2)
array([[ 1.73205081,  3.46410162,  5.19615242,  6.92820323],
       [ 1.73205081,  3.46410162,  5.19615242,  6.92820323]])
>>>

Answer 2

再添加一个循环

# Takes all velocities and converts them to speeds
all_speeds=[]
# Looping over time
for i in range(len(all_velocities)):
    #adding and empty list to collect all the speeds
    all_speeds.append([])
    #looping over number of particles
    for j in range(len(all_velocities[i])):
        all_speeds[-1].append([math.sqrt(all_velocities[i][j][0]**2\
                                         +all_velocities[i][j][1]**2\
                                         +all_velocities[i][j][2]**2)])

希望这会有所帮助。

Answer 3

您只需要在主循环内的粒子数量上增加一个循环。

为了便于阅读，我还创建了一个函数来执行以下代码片段中的速度计算：

import math

all_velocities = [[[1,2,3], [2,3,4]], [[3,4,5], [4,5,6], [7,8,9]]]
all_speeds = []

def calculate_speed(v):
    return math.sqrt(v[0]**2 + v[1]**2 + v[2]**2)

for i in range(len(all_velocities)):
    all_speeds.append([])
    for j in range(len(all_velocities[i])):
        velocity = all_velocities[i][j]
        all_speeds[i].append(calculate_speed(velocity))

print all_speeds

Answer 4

[[math.sqrt(sum(map(lambda x: x**2, body))) for body in frame] for frame in series]

系列具有以下形式：

[[[1, 1, 1], [2, 1, 1], [3, 1, 1]], [[2, 2, 2], [4, 2, 2], [6, 2, 2]]]

Answer 5

我不太清楚你的阵列是什么。我假设它看起来像这样：

system_time_vectors = [
    [
        [x, y, z], # velocity vector for particle 1 at t0 
        [x, y, z], # ... for p2 at t0
        [x, y, z]  # ... for p3 at t0
    ],
    [
        [x, y, z], # for p1 at t1
        [x, y, z], # for p2 at t1
        [x, y, z]  # for p3 at t1
    ]
]

如果是这种情况，那么以下应该可以解决问题。我正在定义一个函数来计算给定矢量的速度。

使用嵌套列表推导，函数to_scalar每次都应用于每个[x, y, z]向量数组。

import math
def to_scalar(*vector_comps):
    return math.sqrt(sum(v*v for v in vector_comps))

speeds = [[to_scalar(*el) for el in moment for moment] in system_time_vectors]

使用Python将速度分量转换为三维数组中的速度

5 个答案: