def test_remove_from_list(self):
n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = get_nodes()
s = Nodes([n1, n2, n3])
s.remove(n3)
s.remove(n7)
self.assertEqual(s, Nodes([n1, n2]))
def test_in_between(self):
p1 = 284.651885, 130.233454, 553.35
p2 = 284.651885, 130.233454, 553.425
p3 = 284.651885, 130.233454, 553.5
p4 = 284.651885, 130.233454, 554.5
n1 = Node(p1, 1)
n2 = Node(p2, 2)
n3 = Node(p3, 3)
n4 = Node(p4, 4)
nodes = Nodes([n1, n2, n3, n4])
res = Nodes(nodes.get_by_volume(p=p1))
self.assertEqual(len(res), 1)
def get_nodes_from_inp(bulk_str, parent):
"""
Extract node information from abaqus input file string
"""
from ada import Node
re_no = re.compile(
r"^\*Node\s*(?:,\s*nset=(?P<nset>.*?)\n|\n)(?P<members>(?:.*?)(?=\*|\Z))",
_re_in,
)
def getnodes(m):
d = m.groupdict()
res = np.fromstring(list_cleanup(d["members"]),
sep=",",
dtype=np.float64)
res_ = res.reshape(int(res.size / 4), 4)
members = [Node(n[1:4], int(n[0]), parent=parent) for n in res_]
if d["nset"] is not None:
parent.sets.add(FemSet(d["nset"], members, "nset", parent=parent))
return members
nodes = list(chain.from_iterable(map(getnodes, re_no.finditer(bulk_str))))
return Nodes(
nodes,
parent=parent,
)
def get_nodes_and_elements(gmsh_session, fem, fem_set_name="all_elements"):
nodes = list(gmsh_session.model.mesh.getNodes(-1, -1))
# Get nodes
fem._nodes = Nodes(
[
Node(
[roundoff(x) for x in gmsh_session.model.mesh.getNode(n)[0]],
n,
parent=fem,
) for n in nodes[0]
],
parent=fem,
)
# Get elements
elemTypes, elemTags, elemNodeTags = gmsh_session.model.mesh.getElements(
2, -1)
elements = []
for k, element_list in enumerate(elemTags):
face, dim, morder, numv, parv, _ = gmsh_session.model.mesh.getElementProperties(
elemTypes[k])
elem_type = gmsh_map[face]
for j, eltag in enumerate(element_list):
nodes = []
for i in range(numv):
idtag = numv * j + i
p1 = elemNodeTags[k][idtag]
nodes.append(fem.nodes.from_id(p1))
el = Elem(eltag, nodes, elem_type, parent=fem)
elements.append(el)
fem._elements = FemElements(elements, fem_obj=fem)
femset = FemSet(fem_set_name, elements, "elset")
fem.sets.add(femset)
def get_nodes(bulk_str, parent):
"""
Imports
:param bulk_str:
:param parent:
:return: SortedNodes object
:rtype: ada.core.containers.SortedNodes
Format of input:
GNODE 1.00000000E+00 1.00000000E+00 6.00000000E+00 1.23456000E+05
GCOORD 1.00000000E+00 2.03000000E+02 7.05000000E+01 5.54650024E+02
"""
from ada import Node
from ada.core.containers import Nodes
def get_node(m):
d = m.groupdict()
return Node(
[float(d["x"]), float(d["y"]),
float(d["z"])],
int(float(d["id"])),
parent=parent,
)
return Nodes(list(
map(get_node, SesamReader.re_gcoord_in.finditer(bulk_str))),
parent=parent)
def test_repr_some(self):
n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = get_nodes()
s = Nodes([n1, n2, n3])
self.assertEqual(
repr(s),
"Nodes([Node([1.0, 1.0, 1.0], 2), Node([1.0, 2.0, 3.0], 1), Node([2.0, 1.0, 8.0], 3)])"
)
def test_not_in(self):
n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = get_nodes()
s = Nodes([n1, n2, n3, n4, n5, n6, n7, n8, n9, n10])
n11 = Node((0, 0, 0), 10000)
assert n11 not in s
assert n10 in s
def test_from_iterables(self):
n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = get_nodes()
def geniter():
yield n1
yield n2
yield n3
g = geniter()
n = Nodes(g)
def test_add_to_list(self):
n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = get_nodes()
s = Nodes([n1, n2, n3])
n20 = Node((1, 1, 8), 20)
n21 = Node((1, 2, 4), 21)
n22 = Node((2, 1, 6), 22)
s.add(n20)
s.add(n21)
s.add(n22)
self.assertEqual(s, Nodes([n2, n20, n1, n21, n22, n3]))
def get_nodes_and_elements(gmsh, fem=None, fem_set_name="all_elements"):
"""
:param gmsh:
:type gmsh: gmsh
:param fem:
:type fem: ada.fem.FEM
:param fem_set_name:
:type fem_set_name: str
"""
from ada.fem import FEM
fem = FEM("AdaFEM") if fem is None else fem
nodes = list(gmsh.model.mesh.getNodes(-1, -1))
# Get nodes
fem._nodes = Nodes(
[
Node(
[roundoff(x) for x in gmsh.model.mesh.getNode(n)[0]],
n,
parent=fem,
) for n in nodes[0]
],
parent=fem,
)
# Get elements
elemTypes, elemTags, elemNodeTags = gmsh.model.mesh.getElements(2, -1)
elements = []
for k, element_list in enumerate(elemTags):
face, dim, morder, numv, parv, _ = gmsh.model.mesh.getElementProperties(
elemTypes[k])
elem_type = gmsh_map[face]
for j, eltag in enumerate(element_list):
nodes = []
for i in range(numv):
idtag = numv * j + i
p1 = elemNodeTags[k][idtag]
nodes.append(fem.nodes.from_id(p1))
el = Elem(eltag, nodes, elem_type, parent=fem)
elements.append(el)
fem._elements = FemElements(elements, fem_obj=fem)
femset = FemSet(fem_set_name, elements, "elset")
fem.sets.add(femset)
def meshio_read_fem(assembly, fem_file, fem_name=None):
"""
Import a FEM file using the meshio package.
:param assembly: Assembly object
:param fem_file: Path to fem file
:param fem_name: Name of FEM model
:type assembly: ada.Assembly
"""
from ada import Node, Part
from . import meshio_to_ada_type
mesh = meshio.read(fem_file)
name = fem_name if fem_name is not None else "Part-1"
fem = FEM(name)
def to_node(data):
return Node(data[1], data[0])
point_ids = mesh.points_id if "points_id" in mesh.__dict__.keys() else [
i + 1 for i, x in enumerate(mesh.points)
]
elem_counter = Counter(0)
cell_ids = (mesh.cells_id if "cells_id" in mesh.__dict__.keys() else
[[next(elem_counter) for cell in cellblock.data]
for cellblock in mesh.cells])
fem._nodes = Nodes([to_node(p) for p in zip(point_ids, mesh.points)])
cell_block_counter = Counter(-1)
def to_elem(cellblock):
block_id = next(cell_block_counter)
return [
Elem(
cell_ids[block_id][i],
[fem.nodes.from_id(point_ids[c]) for c in cell],
meshio_to_ada_type[cellblock.type],
) for i, cell in enumerate(cellblock.data)
]
fem._elements = FemElements(chain.from_iterable(map(to_elem, mesh.cells)))
assembly.add_part(Part(name, fem=fem))
def setUp(self):
n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = get_nodes()
self.n = Nodes([n1, n2, n3])
def test_with_duplicates(self):
n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = get_nodes()
n = Nodes([n1, n2, n1])
assert len(n) == 2
def test_get_by_volume_cylinder(self):
n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = get_nodes()
s = Nodes(get_nodes())
c = Nodes(s.get_by_volume(p=(1.0, 1.0, 0.5), vol_cyl=(0.2, 4, 0.2)))
self.assertEqual(c, Nodes([n2, n6, n9]))
def test_slice_to_end(self):
n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = get_nodes()
self.assertEqual(self.n[7:], Nodes([n8, n7, n10]))
def test_empty(self):
n = Nodes()
self.assertEqual(len(n), 0)
def test_get_by_id_positive(self):
n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = get_nodes()
s = Nodes([n1, n2, n3])
self.assertEqual(s.from_id(1), n1)
self.assertEqual(s.from_id(2), n2)
self.assertEqual(s.from_id(3), n3)
def test_repr_some(self):
n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = get_nodes()
s = Nodes([n1, n2, n3])
self.assertEqual(repr(s), "Nodes(3, min_id: 1, max_id: 3)")
def test_get_by_volume_point(self):
n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = get_nodes()
s = Nodes(get_nodes())
c = Nodes(s.get_by_volume(p=(4.0, 5.0, 1.0)))
self.assertEqual(c, Nodes([n7]))
def test_slice_empty(self):
self.assertEqual(self.n[11:], Nodes())
def test_repr_empty(self):
s = Nodes()
self.assertEqual(repr(s), "Nodes(0, min_id: 0, max_id: 0)")
def test_empty(self):
n = Nodes([])
assert len(n) == 0
def test_slice_arbitrary(self):
n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = get_nodes()
self.assertEqual(self.n[2:4], Nodes([n9, n1]))
def test_get_by_id_negative(self):
n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = get_nodes()
s = Nodes([n1, n2, n3])
with self.assertRaises(ValueError):
s.from_id(4)
def test_negative_not_contained(self):
n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = get_nodes()
n = Nodes([n1, n2, n3, n4, n5, n6, n7, n8, n9, n10])
self.assertFalse(n1 not in n)
def test_get_by_volume_box(self):
n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = get_nodes()
s = Nodes(get_nodes())
c = Nodes(s.get_by_volume(p=(1.5, 0.5, 0.5), vol_box=(4.5, 5.5, 8.5)))
self.assertEqual(c, Nodes([n3, n7, n8]))
def setUp(self):
self.n = Nodes(get_nodes())
def test_from_sequence(self):
all_nodes = get_nodes()
n = Nodes(all_nodes[:3])
assert len(n) == 3
def test_with_duplicates(self):
n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = get_nodes()
n = Nodes([n1, n1, n1])
self.assertEqual(len(n), 1)
def test_concatenate_intersect(self):
n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = get_nodes()
s = Nodes([n1, n2, n3])
t = Nodes([n4, n5, n6])
self.assertEqual(s + t, Nodes([n1, n2, n3, n4, n5, n6]))
