def test_Tetrahedron():
nodes0 = [
Node(0, 0.0, 0.0, 0.0),
Node(1, 0.0, 1.0, 0.0),
Node(2, 1.0, 1.0, 0.0),
Node(3, 0.0, 0.0, 1.0)
]
nodes1 = nodes0[1:] + [Node(4, 1.0, 0.0, 1.0)]
T0 = Tetrahedron(0, nodes0)
T1 = Tetrahedron(1, nodes1)
ok_(T0.nodes < T1.nodes)
ok_(T0.nodes != T1.nodes)
ok_(not T0.nodes > T1.nodes)
ok_(not T0.hasGeometricInfo)
T0.computeGeometricInfo()
ok_(T0.volume == 1.0 / 6.0)
triangleDict = {}
for t in T0.triangles:
triangleDict[t.nodes] = t
edgeDict = {}
for e in T0.edges:
edgeDict[e.nodes] = e
T0_1 = Tetrahedron(0, nodes0, edgeDict=edgeDict)
T0_2 = Tetrahedron(0, nodes0, triangleDict=triangleDict)
T0_3 = Tetrahedron(0, nodes0, edgeDict=edgeDict, triangleDict=triangleDict)
ok_(T0.nodes == T0_1.nodes == T0_2.nodes)
def test_Polygon():
nodeList = [
Node(nodeNumber=1, x=0.5, y=0.5, z=0.5),
Node(nodeNumber=2, x=0.5, y=0.5, z=-0.5),
Node(nodeNumber=3, x=0.5, y=-0.5, z=0.5)
]
polygon = Polygon(12, nodes=nodeList)
ok_(polygon.N == 12)
ok_(len(polygon.nodes) == 3)
nodeList.sort()
ok_(tuple(nodeList) == polygon.nodes)
polygon.edges = [
Edge(0, [nodeList[0], nodeList[1]]),
Edge(1, [nodeList[1], nodeList[2]]),
Edge(2, [nodeList[2], nodeList[0]])
]
edges = getEdgesFromPolygons([polygon])
ok_(len(edges) == 3)
polygon.edges = [
Edge(0, [nodeList[0], nodeList[1]]),
Edge(1, [nodeList[1], nodeList[2]]),
Edge(3, [nodeList[1], nodeList[2]]),
Edge(2, [nodeList[2], nodeList[0]])
]
edges = getEdgesFromPolygons([polygon])
ok_(len(edges) == 3)
def test_Edge():
edge0 = Edge(0, nodes=[Node(0, 0.0, 0.0, 0.0), Node(1, 1.0, 1.0, 1.0)])
edge1 = Edge(1, nodes=[Node(1, 1.0, 1.0, 1.0), Node(2, 2.0, 1.0, 1.0)])
edgesOrdered = [edge0, edge1]
edgesDisordered = {edge1.nodes: edge1, edge0.nodes: edge0}
edgeKeys = edgesDisordered.keys()
edgeKeys.sort()
for e1, e2_key in zip(edgesOrdered, edgeKeys):
ok_(e1.nodes == edgesDisordered[e2_key].nodes)
edge0.computeGeometricInfo()
ok_((edge0.barycenter == EVec(0.5, 0.5, 0.5)).all())
ok_(edge0.length == math.sqrt(3.0))
ok_(edge0.diameter == math.sqrt(3.0))
ok_(edge0.innerDiameter == math.sqrt(3.0))
ok_(edge0.hasGeometricInfo)
nodeSet = set(edge0.nodes + edge1.nodes)
ok_(nodeSet == set(getNodesFromEdges([edge0, edge1])))
def test_Element(self):
nodesCube= [Node(0,0.0,0.0,0.0),
Node(1,0.0,1.0,0.0),
Node(2,1.0,1.0,0.0),
Node(3,1.0,0.0,0.0),
Node(4,0.0,0.0,1.0),
Node(5,0.0,1.0,1.0),
Node(6,1.0,1.0,1.0),
Node(7,1.0,0.0,1.0)]
e0 = Element(elementNumber=1, nodes = nodesCube)
nodesCube.sort()
ok_(e0.N == 1)
for N, n in enumerate(nodesCube):
ok_(e0.nodes[N] == n)
def test_Quadrilateral():
nodes = [
Node(0, 0.0, 0.0, 0.0),
Node(1, 0.0, 1.0, 0.0),
Node(2, 1.0, 1.0, 0.0),
Node(3, 1.0, 0.0, 0.0),
Node(4, 2.0, 1.0, 0.0),
Node(5, 2.0, 0.0, 0.0)
]
edges0 = [
Edge(0, [nodes[0], nodes[1]]),
Edge(1, [nodes[1], nodes[2]]),
Edge(2, [nodes[2], nodes[3]]),
Edge(3, [nodes[3], nodes[0]])
]
edges1 = [
Edge(2, [nodes[3], nodes[2]]),
Edge(4, [nodes[2], nodes[4]]),
Edge(5, [nodes[4], nodes[5]]),
Edge(6, [nodes[5], nodes[3]])
]
q0 = Quadrilateral(0, edges0)
q1 = Quadrilateral(1, edges1)
ok_(q0.nodes < q1.nodes)
ok_(q0.nodes != q1.nodes)
ok_(not q0.nodes > q1.nodes)
ok_(not q0.hasGeometricInfo)
q0.computeGeometricInfo()
ok_(q0.area == 1.0)
def test_Triangle(self):
t0 = Triangle(0,nodes=[Node(0, 0.0, 0.0, 0.0),
Node(1, 0.0, 1.0, 0.0),
Node(2, 1.0, 0.0, 0.0)])
t1 = Triangle(0,nodes=[Node(3, 1.0, 1.0, 0.0),
Node(1, 0.0, 1.0, 0.0),
Node(2, 1.0, 0.0, 0.0)])
ok_(not t0.hasGeometricInfo)
ok_(t0.nodes < t1.nodes)
t0.computeGeometricInfo()
ok_((t0.barycenter == EVec(1.0/3.0,1.0/3.0,0.0)).all())
def test_Node(self):
origin_default = Node()
origin = Node(nodeNumber=0,x=0.0,y=0.0,z=0.0)
ppp = Node(nodeNumber=1, x= 0.5, y= 0.5, z= 0.5)
ppm = Node(nodeNumber=2, x= 0.5, y= 0.5, z=-0.5)
pmp = Node(nodeNumber=3, x= 0.5, y=-0.5, z= 0.5)
pmm = Node(nodeNumber=4, x= 0.5, y=-0.5, z=-0.5)
mpp = Node(nodeNumber=5, x=-0.5, y= 0.5, z= 0.5)
mpm = Node(nodeNumber=6, x=-0.5, y= 0.5, z=-0.5)
mmp = Node(nodeNumber=7, x=-0.5, y=-0.5, z= 0.5)
mmm = Node(nodeNumber=8, x=-0.5, y=-0.5, z=-0.5)
lexicographic_ordering = [ppp, ppm, pmp, pmm, mpp, mpm, mmp, mmm]
ok_(origin.N == 0)
ok_(origin.p[0] == 0.0)
ok_(origin.p[1] == 0.0)
ok_(origin.p[2] == 0.0)
ok_(origin.length == 1.0)
ok_(origin.diameter == 1.0)
ok_((origin.unitNormal == Node.xUnitVector).all())
ok_(origin == origin_default)
ok_(str(origin) == str(origin_default))
ok_(hash(origin) == hash(origin_default))
ok_(ppp > origin)
for i in range(8):
p = lexicographic_ordering[i]
for pg in lexicographic_ordering[:i]:
ok_(pg > p)
ok_(pg >= p)
ok_(pg != p)
for pl in lexicographic_ordering[i+1:]:
ok_(pl < p)
ok_(pl <= p)
ok_(pl != p)
v = EVec(0.25,0.35,0.45)
ntest = Node(29,0.0,0.0,0.0)
ntest.p +=v
ok_((ntest.p == (0.25, 0.35, 0.45)).all())
