Question

我已经编写了一些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))

Answer 1

我会尝试发布一些代码，但我的一般想法如下：创建一个Particle类，它知道它所在的框，它是在__init__中计算的。每个框应该有一个唯一的名称，可能是左下角的坐标（或者用于定位框的任何内容）。

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

粒子类看起来像：

# 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，但我不是那个问的人。计数器（据说）也是高度优化的。

注意：这些代码都没有经过测试，所以你不应该在这里尝试cut-and-paste-and-hope-works方法。

快速计算网格中的粒子

1 个答案: