我正在设计一个有限元库。对于给定的问题，所使用的有限元网格可以具有不同维度的元素(例如四面体和三角形)，并且组合相同维度的不同元素也是可能的(例如四面体和六面体)。因此，我需要一个存储有限元信息的数据结构。最基本的信息是元素的连接性(定义元素的节点 ID)。例如，我需要以某种方式存储三角形元素 4 连接到节点 5、6 和 10。

我的第一次尝试是创建一个索引为维度(0、1、2 或 3)并存储字典的列表。这些字典有字符串键(标识符)，值是 numpy 数组(每行代表一个元素连接)。我需要这样做，因为给定维度的 numpy 数组根据字符串标识符具有不同的形状。

这是类:

import os
from collections import OrderedDict
import numpy.ma as ma

flatten = lambda l: [item for sublist in l for item in sublist]

class ElementData(list):

    def __init__(self, *args, **kwargs):

        self.reset()
        super(ElementData, self).__init__(*args, **kwargs)

    def __iter__(self):
        for k, v in self[self.idx].items():
            for i, e in enumerate(v):
                yield (k,i,e) if not ma.is_masked(e) else (k,i, None)
        self.reset()


    def __call__(self, idx):
        self.idx = idx-1
        return self

    def __getitem__(self, index):
        if index >= len(self):
            self.expand(index)
        return super(ElementData, self).__getitem__(index)

    def __setitem__(self, index, value):
        if index >= len(self):
            self.expand(index)
        list.__setitem__(self, index, value)

    def __str__(self):
        return "Element dimensions present: {}\n".format([i for i in range(len(self)) if self[i]]) + super(ElementData, self).__str__()

    def keys(self):
        return flatten([list(self[i].keys()) for i in range(len(self))])

    def reset(self):
        self.idx = -1
        self.d = -1

    def expand(self, index):
        self.d = max(index, self.d)
        for i in range(index + 1 - len(self)):
            self.append(OrderedDict())

    def strip(self, value=None):
        if not callable(value):
            saved_value, value = value, lambda k,v: saved_value
        return ElementData([OrderedDict({k:value(k, v) for k,v in i.items()}) for i in super(ElementData, self).__iter__()])


    def numElements(self, d):

        def elementsOfDimension(d):
            # loop over etypes
            nelems = 0
            for v in self[d].values():
                nelems += v.shape[0] if not isinstance(v, ma.MaskedArray) else v.shape[0] - v.mask.any(axis=1).sum()
            return nelems

        # compute the number of all elements
        if d == -1:
            nelems = 0
            for i in range(self.d+1):
                nelems += elementsOfDimension(i)
            return nelems
        else: # of specific dimension only
            return elementsOfDimension(d)

该类运行良好，它允许我无缝循环遍历特定维度的所有项目。但是，还有其他数据与单独存储的每个元素相关联，例如其 Material 。因此，我决定使用相同的数据结构来引用其他属性。为此，我使用该类的 strip 函数返回没有 numpy 数组的整个结构。

我的问题是原始数据结构是动态的，如果我改变它，我必须修改依赖它的所有其他结构。我真的认为我在设计这门课时走错了方向。也许有更简单的方法来解决这个问题？我考虑过将额外信息存储在 numpy 数组旁边(例如元组)，但我不知道这是否好。在设计软件时做出的选择确实会让我们以后的生活变得悲惨，我现在开始意识到这一点。

更新

使用上面的类，一个例子如下:

Element dimensions present: [0, 1, 2]
[OrderedDict([('n1', array([[0],
       [1],
       [3]]))]), OrderedDict([('l2', array([[1, 2]]))]), OrderedDict([('q4', array([[0, 1, 5, 4],
       [5, 1, 2, 6],
       [6, 2, 3, 7],
       [7, 3, 0, 4],
       [4, 5, 6, 7]]))])]

其中数据结构已用于存储 0(节点)、1(线)和 2(四边形)维度的元素。

最佳答案

Comment: the design goes against the logical structure of the program.

我使用了给定的元素数据示例，没想到一下子就搞定了全貌。

Comment: Each element has a unique dimension (a triangle has always dimension 2, as a tetrahedron has always dimension 3 and a node dimension 0).

抱歉，我误解了问题“...不同维度的元素...” “元素有不同的维度”。我调整了我的提案。

Comment: ... the problem arises when I modify the data structure (for example by adding elements)

只要您不针对此问题显示数据示例， 我想不出解决方案。

我的建议:

class Dimension(object):
    """
    Base class for all Dimensions
    Dimension has no knowledge to what the data belongs to
    """
    def __init__(self, data=None):
        pass

class Element(object):
    """
    Base class for all Elements
    Hold on class Dimension(object):
    """
    def __init__(self, dimension=None):
        pass

class Triangle(Element):
    def __init__(self, dimension):
        super().__init__(dimension=dimension)

class Tetrahedron(Element):
    def __init__(self, dimension):
        super().__init__(dimension=dimension)

class Node(Element):
    def __init__(self, dimension):
        super().__init__(dimension=dimension)

用法:构建示例元素

node = Node(dimension=[0,1,3])
line = Triangle(dimension=[0,2])
quad = Tetrahedron(dimension=[[0, 1, 5, 4], [5, 1, 2, 6], [6, 2, 3, 7], [7, 3, 0, 4], [4, 5, 6, 7]])

新的 Future 元素，仅显示 class Element 可以扩展:

# New future dimensions - No changes to class Element() required
class FutureNodTriTet(Element):
    def __init__(self, dimension):
        super().__init__(dimension=dimension)

future_NTT = FutureNodTriTet(dimension=[0, (1,3), (4,5,6)])

如果这更接近您的需求，请发表评论。

关于python - 设计复杂的数据结构依赖，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/43162101/