def test_pcanodes(self, value):
filepath = 'data/%s.mesh' % (value)
mesh0 = mesher.Mesh()
mesh0.add_stdnode('weights', [1, 1, -0.1])
mesh0.add_stdnode('vars', [1, 0.1, 0.04])
mesh0.add_pcanode(1, [[[0.5, 0.1, 0.01]], [[0.7, 0.2, 0.02]]], 'weights', 'vars')
mesh0.add_pcanode(2, [[[0.0, -0.1, 0.01]], [[0.0, 0.02, -0.01]]], 'weights', 'vars')
mesh0.add_element(1, ['L1'], [2, 1])
mesh0.generate()
mesh0.save(filepath, format=value)
mesh1 = mesher.Mesh(filepath)
npt.assert_equal(mesh0.nodes[1].values, mesh1.nodes[1].values)
npt.assert_equal(mesh0.nodes[2].values, mesh1.nodes[2].values)
npt.assert_equal(mesh0.elements[1].evaluate([0.3]),
mesh1.elements[1].evaluate([0.3]))
weights = numpy.array([1, -0.1, 0.2])
mesh0.nodes['weights'].values = weights
mesh0.update_pca_nodes()
mesh1.nodes['weights'].values = weights
mesh1.update_pca_nodes()
npt.assert_equal(mesh0.nodes[1].values, mesh1.nodes[1].values)
npt.assert_equal(mesh0.nodes[2].values, mesh1.nodes[2].values)
npt.assert_equal(mesh0.elements[1].evaluate([0.3]),
mesh1.elements[1].evaluate([0.3]))
npt.assert_equal(mesh0.core.P, mesh1.core.P)
def test_groups(self, value):
def compare_node_groups(mesh0, mesh1, group):
nids0 = [n.id for n in mesh0.nodes.groups[group]]
nids1 = [n.id for n in mesh1.nodes.groups[group]]
self.assertEqual(nids0, nids1)
def compare_elem_groups(mesh0, mesh1, group):
nids0 = [n.id for n in mesh0.elements.groups[group]]
nids1 = [n.id for n in mesh1.elements.groups[group]]
self.assertEqual(nids0, nids1)
filepath = 'data/%s.mesh' % (value)
mesh0 = mesher.Mesh()
mesh0.add_stdnode(1, [0., 0.])
mesh0.add_stdnode('2', [3., 0.])
mesh0.add_stdnode(3, [0., 4.])
mesh0.add_element(1, ['L1'], [1, '2'])
mesh0.add_element(2, ['L1'], [1, 3])
mesh0.add_element('hypotenuse', ['L1'], ['2', 3])
mesh0.nodes.add_to_group(1, 'origin')
mesh0.nodes.add_to_group(['2', 3], 5)
mesh0.nodes.add_to_group(['2', 3, 1], 'all')
mesh0.elements.add_to_group([1, 2], 12)
mesh0.elements.add_to_group('hypotenuse', 'hypotenuse')
mesh0.elements.add_to_group([1, 2, 'hypotenuse'], 'loop')
mesh0.generate()
mesh0.save(filepath, format=value)
mesh1 = mesher.Mesh(filepath)
compare_node_groups(mesh0, mesh1, 'origin')
compare_node_groups(mesh0, mesh1, 5)
compare_node_groups(mesh0, mesh1, 'all')
compare_elem_groups(mesh0, mesh1, 12)
compare_elem_groups(mesh0, mesh1, 'hypotenuse')
compare_elem_groups(mesh0, mesh1, 'loop')
def test_metadata(self, value):
filepath = 'data/%s.mesh' % (value)
mesh0 = mesher.Mesh(label='cube', units='mm')
mesh0.metadata.name = 'Joe Bloggs'
mesh0.metadata.age = 23
mesh0.metadata.height = 1.68
mesh0.metadata.list1 = ['c', 'a', 'b']
mesh0.metadata.list2 = [2, 1, 3]
mesh0.metadata.list3 = [2.1, 1.1, 3.1]
mesh0.metadata.list4 = [1, 'a', 3.3]
mesh0.metadata.dict4 = {'a':1, 'b':'c'}
mesh0.add_stdnode(1, [0.5])
mesh0.generate()
mesh0.save(filepath, format=value)
mesh1 = mesher.Mesh(filepath)
self.assertEqual(mesh1.metadata.name, 'Joe Bloggs')
self.assertEqual(mesh1.metadata.age, 23)
self.assertEqual(mesh1.metadata.height, 1.68)
self.assertEqual(mesh1.metadata.list1, ['c', 'a', 'b'])
self.assertEqual(mesh1.metadata.list2, [2, 1, 3])
self.assertEqual(mesh1.metadata.list3, [2.1, 1.1, 3.1])
self.assertEqual(mesh1.metadata.list4, [1, 'a', 3.3])
self.assertEqual(mesh1.metadata.dict4, {'a':1, 'b':'c'})
def test_depnodes(self, value):
filepath = 'data/%s.mesh' % (value)
mesh0 = mesher.Mesh()
mesh0.add_stdnode('xi', [0.5])
mesh0.add_stdnode(1, [0.0, 0.0])
mesh0.add_stdnode(2, [1, 0.5])
mesh0.add_depnode(3, 1, 'xi')
mesh0.add_element(1, ['L1'], [1, 2])
mesh0.generate()
mesh0.save(filepath, format=value)
mesh1 = mesher.Mesh(filepath)
npt.assert_equal(mesh0.nodes[3].values, mesh1.nodes[3].values)
npt.assert_equal(mesh0.core.P, mesh1.core.P)
def test_set_method_no_overwrite(self):
mesh = mesher.Mesh()
mesh.metadata.age = 23
self.assertEqual(mesh.metadata.age, 23)
result = mesh.metadata.set('age', 25, False)
self.assertFalse(result)
self.assertEqual(mesh.metadata.age, 23)
def test_delete_method(self):
mesh = mesher.Mesh()
self.assertFalse('age' in mesh.metadata.keys())
mesh.metadata.age = 23
self.assertTrue('age' in mesh.metadata.keys())
mesh.metadata.delete('age')
self.assertFalse('age' in mesh.metadata.keys())
def test_set_dict(self):
d = {'name': 'Joe Bloggs', 'age': 23, 'height': 1.68}
mesh = mesher.Mesh()
mesh.metadata.set_dict(d)
self.assertEqual(mesh.metadata.name, 'Joe Bloggs')
self.assertEqual(mesh.metadata.age, 23)
self.assertEqual(mesh.metadata.height, 1.68)
def test_set_slices(self):
mesh = mesher.Mesh()
Xn1 = numpy.array([[0, 0.1, 0.2], [0.3, 0.4, 0.5]])
Xn2 = numpy.array([[11, 12, 13], [15, 16, 66]])
P = numpy.append(Xn1.flatten(), Xn2.flatten())
node1 = mesh.add_stdnode(1, Xn1)
node2 = mesh.add_stdnode(2, Xn2)
npt.assert_equal(mesh._core.P, P)
npt.assert_equal(node1.values, Xn1)
npt.assert_equal(node2.values, Xn2)
x = [99, 33]
Xn1[:, 0], P[[0, 3]], node1.values[:, 0] = x, x, x
npt.assert_equal(mesh._core.P, P)
npt.assert_equal(node1.values, Xn1)
x = [11, 22]
Xn2[1, 1:], P[[10, 11]], node2.values[1, 1:] = x, x, x
npt.assert_equal(mesh._core.P, P)
npt.assert_equal(node2.values, Xn2)
x = 11
Xn2[1, 0], P[9], node2.values[1, 0] = x, x, x
npt.assert_equal(mesh._core.P, P)
npt.assert_equal(node2.values, Xn2)
x = [23, 45]
Xn1[0, -2:], P[[1, 2]], node1.values[0, -2:] = x, x, x
npt.assert_equal(mesh._core.P, P)
npt.assert_equal(node1.values, Xn1)
def test_add(self):
mesh = mesher.Mesh()
node1 = mesher.StdNode(mesh, 1, [0.1])
node2 = mesher.DepNode(mesh, 2, 1, 1)
node3 = mesher.StdNode(mesh, 3, [0.3])
nodea = mesher.StdNode(mesh, 'a', [0.3])
mol = core.ObjectList()
mol.add(node1)
mol.add(node2)
mol.add(node3)
mol.add(nodea)
self.assertEqual(mol._objects[0], node1)
self.assertEqual(mol._objects[1], node2)
self.assertEqual(mol._objects[2], node3)
self.assertEqual(mol._objects[3], nodea)
Nodes = [node1, node2, node3, nodea]
for i, node in enumerate(mol):
self.assertEqual(node, Nodes[i])
Nodes = [node3, node1]
for i, node in enumerate(mol[[3, 1]]):
self.assertEqual(node, Nodes[i])
self.assertEqual(mol[1], node1)
self.assertEqual(mol[2], node2)
self.assertEqual(mol[3], node3)
self.assertEqual(mol['a'], nodea)
def test_set_all_different_shape(self):
mesh = mesher.Mesh()
Xn = numpy.array([[0, 0.1, 0.2], [0.3, 0.4, 0.5]])
node = mesh.add_stdnode(1, Xn)
Xn2 = numpy.array([[11, 12], [15, 16], [22, 33]])
self.assertRaises(IndexError, self.assign_function, node, Xn2)
def test_stdnodes(self, value):
filepath = 'data/%s.mesh' % (value)
mesh0 = mesher.Mesh()
mesh0.add_stdnode(1, [0.5, 0.5])
mesh0.add_stdnode(2, [0.0, 0.3])
mesh0.add_stdnode('2', [[1.0, 0.5],[0.9, 1.3]])
mesh0.add_element(1, ['L1'], [1, 2])
mesh0.generate()
mesh0.save(filepath, format=value)
mesh1 = mesher.Mesh(filepath)
for node in mesh0.nodes:
nid = node.id
npt.assert_equal(node.id, mesh1.nodes[nid].id)
npt.assert_equal(mesh0.nodes[nid].values, mesh1.nodes[nid].values)
npt.assert_equal(mesh0.core.P, mesh1.core.P)
def test_get_dict(self):
mesh = mesher.Mesh()
mesh.metadata.name = 'Joe Bloggs'
mesh.metadata.age = 23
mesh.metadata.height = 1.68
d = mesh.metadata.get_dict()
self.assertEqual(d, {'name': 'Joe Bloggs', 'age': 23, 'height': 1.68})
def test_metadata(self, value):
filepath = 'data/%s.mesh' % (value)
mesh0 = mesher.Mesh(label='cube', units='mm')
mesh0.add_stdnode(1, [0.5])
mesh0.generate()
mesh0.save(filepath, format=value)
mesh1 = mesher.Mesh(filepath)
self.assertEqual(mesh0.version, mesh1.version)
self.assertEqual(mesh1.version, 1)
self.assertEqual(mesh0.created_at, mesh1.created_at)
self.assertEqual(mesh1.created_at[:2], "20")
self.assertEqual(mesh1.created_at[-3:], "UTC")
self.assertEqual(mesh1.saved_at[:2], "20")
self.assertEqual(mesh1.saved_at[-3:], "UTC")
self.assertEqual(mesh0.label, mesh1.label)
self.assertEqual(mesh0.units, mesh1.units)
def test_data_types(self):
mesh = mesher.Mesh()
mesh.metadata.name = 'Joe Bloggs'
self.assertEqual(mesh.metadata.name, 'Joe Bloggs')
mesh.metadata.age = 23
self.assertEqual(mesh.metadata.age, 23)
mesh.metadata.height = 1.68
self.assertEqual(mesh.metadata.height, 1.68)
def test_1d_slices_v4(self):
mesh = mesher.Mesh()
Xn = numpy.array([0, 0.1, 0.2, 0.3, 0.4])
Xn2 = numpy.array([0, 0.1, 3, 0.3, 0.4])
node = mesh.add_stdnode(1, Xn)
npt.assert_equal(mesh._core.P, Xn.flatten())
npt.assert_equal(node.values, Xn)
node.values[2:3:2] = 3
npt.assert_equal(node.values, Xn2)
def test_2d_slices(self):
mesh = mesher.Mesh()
Xn = numpy.array([[0, 0.1, 0.2], [1, 2, 3]])
Xn2 = numpy.array([[0, 0.1, 0.2], [1, 5, 5]])
node = mesh.add_stdnode(1, Xn)
npt.assert_equal(mesh._core.P, Xn.flatten())
npt.assert_equal(node.values, Xn)
node.values[1, 1:] = 5
npt.assert_equal(node.values, Xn2)
def test_update_from_mesh(self):
mesh = mesher.Mesh()
mesh.add_stdnode(1, [0, 0, 1])
mesh.add_stdnode(2, [1, 0, 2])
mesh.add_element(9, ['L1'], [1, 2])
mesh.generate()
pt = fitter.BoundNodeValue(2, 1, 0, 'datacloud')
pt.update_from_mesh(mesh)
self.assertEqual(pt.param_ids, 4)
npt.assert_almost_equal(pt.param_weights, 1)
def test_nodevalues_init(self):
mesh = mesher.Mesh()
Xn = numpy.array([[0, 0.1, 0.2], [0.3, 0.4, 0.5]])
node = mesh.add_stdnode(1, Xn)
npt.assert_equal(node.values, Xn)
npt.assert_equal(node.values[:, 0], Xn[:, 0])
npt.assert_equal(node.values[1, :], Xn[1, :])
npt.assert_equal(node.values[1, 1], Xn[1, 1])
npt.assert_equal(node.values[:, :2], Xn[:, :2])
npt.assert_equal(mesh._core.P, Xn.flatten())
def test_set_all(self):
mesh = mesher.Mesh()
Xn = numpy.array([[0, 0.1, 0.2], [0.3, 0.4, 0.5]])
node = mesh.add_stdnode(1, Xn)
npt.assert_equal(mesh._core.P, Xn.flatten())
npt.assert_equal(node.values, Xn)
Xn2 = numpy.array([[11, 12, 13], [15, 16, 66]])
node.values = numpy.array([[11., 12, 13], [15, 16, 66]])
npt.assert_equal(mesh._core.P, Xn2.flatten())
npt.assert_equal(node.values, Xn2)
def test_elements(self, value):
filepath = 'data/%s.mesh' % (value)
mesh0 = mesher.Mesh()
mesh0.add_stdnode(1, [0.5, 0.7, 1.2])
mesh0.add_stdnode(2, [0.0, 0.3, 0.4])
mesh0.add_element(1, ['L1'], [1, 2])
mesh0.add_element('-1', ['L1'], [2, 1])
mesh0.generate()
mesh0.save(filepath, format=value)
mesh1 = mesher.Mesh(filepath)
for ne, el0 in enumerate(mesh0.elements):
el1 = mesh1.elements[el0.id]
self.assertEqual(el0.id, el1.id)
self.assertEqual(el0.basis, el1.basis)
self.assertEqual(el0.node_ids, el1.node_ids)
npt.assert_equal(mesh0.elements[1].evaluate([0.3]),
mesh1.elements[1].evaluate([0.3]))
npt.assert_equal(mesh0.elements[1].length(),
mesh1.elements[1].length())
def test_update_from_mesh(self):
mesh = mesher.Mesh()
mesh.add_stdnode(1, [0, 0, 1])
mesh.add_stdnode(2, [1, 0, 2])
mesh.add_element(9, ['L1'], [1, 2])
mesh.generate()
pt = fitter.BoundElementPoint(9, [0.3],
'datacloud',
data_index=0,
weight=2)
pt.update_from_mesh(mesh)
self.assertEqual(pt.param_ids, [[0, 3], [1, 4], [2, 5]])
npt.assert_almost_equal(pt.param_weights, [0.7, 0.3])
self.assertEqual(pt.num_fields, 3)
def setUp(self):
self.mesh = mesher.Mesh()
self.mesh.add_stdnode(1, [0., 0., 0.])
self.mesh.add_stdnode(2, [1., 0., 1.])
self.mesh.add_stdnode(3, [0., 1., 2.])
self.mesh.add_stdnode(4, [1., 1., 1.])
self.mesh.add_element(1, ['L1', 'L1'], [1, 2, 3, 4])
self.mesh.nodes[1].variables(True)
self.mesh.nodes[2].variables(True)
self.mesh.nodes[3].variables(True)
self.mesh.nodes[4].variables(True)
self.mesh.generate()
def test_contains(self):
mesh = mesher.Mesh()
node1 = mesher.StdNode(mesh, 1, [0.1])
node2 = mesher.DepNode(mesh, 2, 1, 1)
node3 = mesher.StdNode(mesh, 3, [0.3])
nodea = mesher.StdNode(mesh, 'a', [0.3])
mol = core.ObjectList()
mol.add(node1)
mol.add(node2)
mol.add(node3)
mol.add(nodea)
self.assertTrue(1 in mol)
self.assertTrue(2 in mol)
self.assertTrue(3 in mol)
self.assertTrue('a' in mol)
self.assertFalse(5 in mol)
self.assertFalse('b' in mol)
def test_bind_subset_of_fields(self):
mesh = mesher.Mesh()
mesh.add_stdnode(1, [0, 0, 0])
mesh.add_stdnode(2, [2, 0.9, 2.4])
mesh.add_element('el1', ['L1'], [1, 2])
mesh.generate()
fit = fitter.Fit()
fit.bind_element_point('el1', [0.3], 'x3', weight=2, fields=[0])
fit.bind_element_point('el1', [0.3],
'datacloud',
weight=2,
fields=[1, 2])
fit.bind_element_point('el1', [0.8],
'datacloud',
weight=2,
fields=[2, 1])
fit.bind_element_point('el1', [0.9], 'x9', weight=2, fields=[0])
fit.update_from_mesh(mesh)
npt.assert_almost_equal(
fit.A.toarray(),
[[1.4, 0., 0., 0.6, 0., 0.], [0., 1.4, 0., 0., 0.6, 0.],
[0., 0., 1.4, 0., 0., 0.6], [0., 0., 0.4, 0., 0., 1.6],
[0., 0.4, 0., 0., 1.6, 0.], [0.2, 0., 0., 1.8, 0., 0.]])
Xd = numpy.array([[0, 0, 0], [0.5, 0.3, 1.1], [1.7, 0.8, 2.1],
[1, 0.5, 1.5]])
fit.set_data('datacloud', Xd)
fit.set_data('x3', 0.6)
fit.set_data('x9', 1.8)
fit.generate_fast_data()
for data in fit.data:
data.update_point_data(mesh._core.P[fit.param_ids])
b = fit.get_data(mesh)
npt.assert_almost_equal(b, [0.6, 0.3, 1.1, 2.1, 0.8, 1.8])
mesh, err = fit.solve(mesh)
npt.assert_almost_equal(mesh.get_nodes(),
[[0, 0, 0.5], [2.0, 1.0, 2.5]])
def test_3d_node_data(self):
mesh = mesher.Mesh()
Xn = numpy.array([[[1, 0.2, 0.1], [2, 0.55, 0.11]],
[[2.1, 0.02, 0.01], [2.3, 0.15, 0.06]]])
Xn2 = numpy.array([[[2, 0.2, 0.1], [2, 0.55, 0.11]],
[[4.2, 0.02, 0.01], [2.3, 0.15, 0.06]]])
node = mesh.add_stdnode(1, Xn)
npt.assert_equal(node.num_fields, 2)
npt.assert_equal(node.num_components, 2)
npt.assert_equal(node.num_modes, 3)
npt.assert_equal(node.shape, (2, 2, 3))
npt.assert_equal(node.values, Xn)
npt.assert_equal(node.values[:, 0, 0], Xn[:, 0, 0])
npt.assert_equal(node.values[1, :, 0], Xn[1, :, 0])
npt.assert_equal(node.values[1, :, :], Xn[1, :, :])
node.values[:, 0, 0] *= 2
npt.assert_equal(node.values, Xn2)
def generate():
# sphinx tag generate 0
x = scipy.linspace(0, 2 * scipy.pi, 7)
y = scipy.cos(x)
X = scipy.array([x, y]).T
# Start Generate Mesh
mesh = mesher.Mesh() # Instantiate a mesh
# Add nodes
mesh.add_stdnode(1, X[0, :])
mesh.add_stdnode(2, X[1, :])
mesh.add_stdnode(3, X[2, :])
mesh.add_stdnode(4, X[3, :])
mesh.add_stdnode(5, X[4, :])
mesh.add_stdnode(6, X[5, :])
mesh.add_stdnode(7, X[6, :])
# sphinx tag generate 1
# sphinx tag generate 2
# Add two cubic elements each having 3 nodes
mesh.add_element(1, ['L3'], [1, 2, 3, 4])
mesh.add_element(2, ['L3'], [4, 5, 6, 7])
# sphinx tag generate 3
# Calculate coordinates and derivatives at evaluated points
# sphinx tag generate 4
S = [0.2, 0.6]
Xe = mesh.evaluate(1, S)
dXe = mesh.evaluate(1, S, deriv=[1])
# sphinx tag generate 5
print Xe
print dXe
# Plot data
# sphinx tag plotting 1
x = scipy.linspace(0, 2 * scipy.pi, 20)
y = scipy.sin(x)
Xd = scipy.array([x, y]).T
return mesh, Xd
def test_group(self):
mesh = mesher.Mesh()
node1 = mesher.StdNode(mesh, 1, [0.1])
node2 = mesher.DepNode(mesh, 2, 1, 1)
node3 = mesher.StdNode(mesh, 3, [0.3])
node4 = mesher.StdNode(mesh, 4, [0.3])
mol = core.ObjectList()
mol.add(node1, group='g1')
mol.add(node2, group='g2')
mol.add(node3, group='g3')
mol.add(node4, group='g2')
mol.add_to_group(2, 'dependent_nodes')
mol.add_to_group([1, 3, 4], 'standard_nodes')
self.assertEqual(mol._get_group('g1'), [node1])
self.assertEqual(mol._get_group('g2'), [node2, node4])
self.assertEqual(mol._get_group('g3'), [node3])
self.assertEqual(mol._get_group('dependent_nodes'), [node2])
self.assertEqual(mol._get_group('standard_nodes'),
[node1, node3, node4])
def generate_mesh(X):
# Start Generate Mesh
mesh = mesher.Mesh() # Instantiate a mesh
# NODES
# add nodes starting the node ids at 0
for i, x in enumerate(X):
mesh.add_stdnode(i, x)
# ELEMENTS
# Add four linear elements each having 3 nodes
# Note: uid=None will generate a unique id automatically
mesh.add_element(None, ['L1'], [0, 6], group='4linear')
mesh.add_element(None, ['L1'], [6, 12], group='4linear')
mesh.add_element(None, ['L1'], [12, 18], group='4linear')
mesh.add_element(None, ['L1'], [18, 24], group='4linear')
# Add two quadratic elements each having 3 nodes
mesh.add_element(None, ['L2'], [0, 6, 12], group='2quadratics')
mesh.add_element(None, ['L2'], [12, 18, 24], group='2quadratics')
# Add two cubic elements each having 4 nodes
mesh.add_element(None, ['L3'], [0, 4, 8, 12], group='2cubics')
mesh.add_element(None, ['L3'], [12, 16, 20, 24], group='2cubics')
# Add two quartics elements each having 5 nodes
mesh.add_element(None, ['L4'], [0, 3, 6, 9, 12], group='2quartics')
mesh.add_element(None, ['L4'], [12, 15, 18, 21, 24], group='2quartics')
# GROUPS
mesh.nodes.add_to_group([0, 6, 12, 18, 24], '4linear')
mesh.nodes.add_to_group([0, 6, 12, 18, 24], '2quadratics')
mesh.nodes.add_to_group([0, 4, 8, 12, 16, 20, 24], '2cubics')
mesh.nodes.add_to_group([0, 3, 6, 9, 12, 15, 18, 21, 24], '2quartics')
# End Generate Mesh
return mesh
def test_save_empty_mesh(self, value):
filepath = 'data/%s.mesh' % (value)
mesh0 = mesher.Mesh(label='cube', units='mm')
mesh0.generate()
def setUp(self):
self.mesh = mesher.Mesh()
self.mesh.add_stdnode(1, [0, 0])
self.mesh.add_stdnode(2, [1, 0])
self.mesh.add_element(9, ['L1'], [1, 2])
self.mesh.generate()
