0

我编写了一些 python 代码来计算宇宙模拟中的某个数量。它通过检查是否包含在大小为 8,000^3 的盒子中的粒子来做到这一点，从原点开始并在找到包含在其中的所有粒子时推进盒子。由于我总共计算了大约 200 万个粒子，并且模拟体积的总大小为 150,000^3，因此这需要很长时间。

我将在下面发布我的代码，有人对如何改进它有任何建议吗？

提前致谢。

from __future__ import division
import numpy as np




def check_range(pos, i, j, k):
    a = 0
    if i <= pos[2] < i+8000:
            if j <= pos[3] < j+8000:
                    if k <= pos[4] < k+8000:
                            a = 1
    return a


def sigma8(data):

    N = []

    to_do = data

    print 'Counting number of particles per cell...'

    for k in range(0,150001,8000):
            for j in range(0,150001,8000):
                    for i in range(0,150001,8000):
                            temp = []
                            n = []
                            for count in range(len(to_do)):
                                    n.append(check_range(to_do[count],i,j,k))
                                    to_do[count][1] = n[count]
                                    if to_do[count][1] == 0:
                                           temp.append(to_do[count])
                                    #Only particles that have not been found are
                                    # searched for again

                            to_do = temp
                            N.append(sum(n))
                    print 'Next row'
            print 'Next slice, %i still to find' % len(to_do)

    print 'Calculating sigma8...'

    if not sum(N) == len(data):
            return 'Error!\nN measured = {0}, total N = {1}'.format(sum(N), len(data))

    else:
            return 'sigma8 = %.4f, variance = %.4f, mean = %.4f' % (np.sqrt(sum((N-np.mean(N))**2)/len(N))/np.mean(N), np.var(N),np.mean(N))
4

1 回答 1

2

我将尝试发布一些代码，但我的总体想法如下：创建一个知道它所在的盒子的 Particle 类，该类在__init__. 每个盒子都应该有一个唯一的名称，它可能是左下角的坐标（或者你用来定位盒子的任何东西）。

为每个粒子获取一个 Particle 类的新实例，然后使用 Counter（来自集合模块）。

粒子类看起来像：

# static consts - outside so that every instance of Particle doesn't take them along
# for the ride...
MAX_X = 150,000
X_STEP = 8000
# etc.

class Particle(object):

    def __init__(self, data):
        self.x = data[xvalue]
        self.y = data[yvalue]
        self.z = data[zvalue]
        self.compute_box_label()

    def compute_box_label(self):
        import math

        x_label = math.floor(self.x / X_STEP)
        y_label = math.floor(self.y / Y_STEP)
        z_label = math.floor(self.z / Z_STEP) 
        self.box_label = str(x_label) + '-' + str(y_label) + '-' + str(z_label)

无论如何，我想你的sigma8功能可能看起来像：

def sigma8(data):
    import collections as col

    particles = [Particle(x) for x in data]
    boxes = col.Counter([x.box_label for x in particles])
    counts = boxes.most_common()

    #some other stuff

counts将是一个元组列表，将框标签映射到该框中的粒子数。（这里我们将粒子视为无法区分。）

使用列表推导比使用循环快得多——我认为原因是您基本上更多地依赖于底层 C，但我不是要问的人。Counter （据说）也是高度优化的。

注意：这些代码都没有经过测试，所以你不应该在这里尝试剪切粘贴和希望它的工作方法。

于 2013-02-24T22:45:19.857 回答