def test_mesh_snapshot(self):
filename = self.filename
points = numpy.array([
[0, 0, 0], [1, 0, 0], [0, 1, 0], [0, 0, 1],
[2, 0, 0], [3, 0, 0], [3, 1, 0], [2, 1, 0],
[2, 0, 1], [3, 0, 1], [3, 1, 1], [2, 1, 1]],
'f')
mesh = Mesh('test')
point_iter = (Point(coordinates=point) for point in points)
mesh.add(point_iter)
snapshot(mesh, filename)
self.assertImageSavedWithContent(filename)
def test_mesh_show(self):
points = numpy.array([
[0, 0, 0], [1, 0, 0], [0, 1, 0], [0, 0, 1],
[2, 0, 0], [3, 0, 0], [3, 1, 0], [2, 1, 0],
[2, 0, 1], [3, 0, 1], [3, 1, 1], [2, 1, 1]],
'f')
mesh = Mesh('test')
point_iter = (Point(coordinates=point) for point in points)
mesh.add(point_iter)
def function():
show(mesh)
return True
tester = ModalDialogTester(function)
tester.open_and_run(when_opened=lambda x: x.close(accept=False))
self.assertTrue(tester.result)
def test_initialization_from_cuds(self):
# given
count = itertools.count()
points = [
Point(coordinates=point, data=DataContainer(TEMPERATURE=index))
for index, point in enumerate(self.points)]
container = Mesh('test')
container.add(points)
faces = [
Face(
points=[points[index].uid for index in face],
data=DataContainer(TEMPERATURE=next(count)))
for face in self.faces]
edges = [
Edge(
points=[points[index].uid for index in edge],
data=DataContainer(TEMPERATURE=next(count)))
for edge in self.edges]
cells = [
Cell(
points=[points[index].uid for index in cell],
data=DataContainer(TEMPERATURE=next(count)))
for cell in self.cells]
container.add(edges)
container.add(faces)
container.add(cells)
# when
vtk_container = VTKMesh.from_mesh(container)
# then
self.assertEqual(vtk_container.name, container.name)
self.assertEqual(sum(1 for _ in vtk_container.iter(
item_type=CUBA.POINT)), 12)
self.assertEqual(sum(1 for _ in vtk_container.iter(
item_type=CUBA.EDGE
)), 2)
self.assertEqual(sum(1 for _ in vtk_container.iter(
item_type=CUBA.FACE
)), 1)
self.assertEqual(sum(1 for _ in vtk_container.iter(
item_type=CUBA.CELL
)), 2)
for point in points:
self.assertEqual(vtk_container.get(point.uid), point)
for edge in edges:
self.assertEqual(vtk_container.get(edge.uid), edge)
for face in faces:
self.assertEqual(vtk_container.get(face.uid), face)
for cell in cells:
self.assertEqual(vtk_container.get(cell.uid), cell)
class NumerrinPoolTestCase(unittest.TestCase):
"""Test case for NumerrinPool class"""
def setUp(self):
self.mesh = Mesh(name="mesh1")
numerrin.initlocal("", "PYNUMERRIN_LICENSE", liccode)
self.points = [
Point((0.0, 0.0, 0.0),
data=DataContainer({
CUBA.VELOCITY: (1, 0, 0),
CUBA.PRESSURE: 4.0
})),
Point((1.0, 0.0, 0.0),
data=DataContainer({
CUBA.VELOCITY: (1, 0, 0),
CUBA.PRESSURE: 4.0
})),
Point((1.0, 1.0, 0.0),
data=DataContainer({
CUBA.VELOCITY: (1, 0, 0),
CUBA.PRESSURE: 4.0
})),
Point((0.0, 1.0, 0.0),
data=DataContainer({
CUBA.VELOCITY: (1, 0, 0),
CUBA.PRESSURE: 4.0
})),
Point((0.0, 0.0, 1.0),
data=DataContainer({
CUBA.VELOCITY: (1, 0, 0),
CUBA.PRESSURE: 4.0
})),
Point((1.0, 0.0, 1.0),
data=DataContainer({
CUBA.VELOCITY: (1, 0, 0),
CUBA.PRESSURE: 4.0
})),
Point((1.0, 1.0, 1.0),
data=DataContainer({
CUBA.VELOCITY: (1, 0, 0),
CUBA.PRESSURE: 4.0
})),
Point((0.0, 1.0, 1.0),
data=DataContainer({
CUBA.VELOCITY: (1, 0, 0),
CUBA.PRESSURE: 4.0
}))
]
puids = self.mesh.add(self.points)
self.faces = [
Face([puids[0], puids[3], puids[7], puids[4]],
data=DataContainer({CUBA.LABEL: 0})),
Face([puids[1], puids[2], puids[6], puids[5]],
data=DataContainer({CUBA.LABEL: 1})),
Face([puids[0], puids[1], puids[5], puids[4]],
data=DataContainer({CUBA.LABEL: 2})),
Face([puids[3], puids[2], puids[6], puids[7]],
data=DataContainer({CUBA.LABEL: 3})),
Face([puids[0], puids[1], puids[2], puids[3]],
data=DataContainer({CUBA.LABEL: 4})),
Face([puids[4], puids[5], puids[6], puids[7]],
data=DataContainer({CUBA.LABEL: 5}))
]
self.edge = Edge([puids[0], puids[3]])
self.mesh.add(self.faces)
self.cells = [Cell(puids)]
self.puids = puids
self.mesh.add(self.cells)
self.variablename = self.mesh.name + "Velocity"
self.variable = tuple([(0.0, 0.0, 0.0) for _ in self.points])
self.boundaries = {}
for i in range(6):
self.boundaries['boundary' + str(i)] = [self.faces[i].uid]
def test_import_mesh(self):
"""Test import_mesh method
"""
pool = NumerrinPool()
pool.import_mesh(self.mesh.name, self.mesh, self.boundaries)
self.assertEqual(
numerrin.meshsize(pool.ph, self.mesh.name)[0], len(self.points))
self.assertEqual(
numerrin.meshsize(pool.ph, self.mesh.name)[2], len(self.faces))
self.assertEqual(
numerrin.meshsize(pool.ph, self.mesh.name)[3], len(self.cells))
def test_clear(self):
"""Test clear method
"""
pool = NumerrinPool()
pool.import_mesh(self.mesh.name, self.mesh, self.boundaries)
pool.clear()
with self.assertRaises(RuntimeError):
numerrin.meshsize(pool.ph, self.mesh.name)
def test_variable_type(self):
"""Test variable_type method
"""
pool = NumerrinPool()
pool.import_mesh(self.mesh.name, self.mesh, self.boundaries)
self.assertEqual(pool.variable_type(self.mesh.name), "Mesh")
def test_variable_rank(self):
"""Test variable_rank method
"""
pool = NumerrinPool()
pool.put_variable(self.variablename, self.variable)
self.assertEqual(pool.variable_rank(self.variablename), 2)
def test_get_variable(self):
"""Test get_variable method
"""
pool = NumerrinPool()
pool.put_variable(self.variablename, self.variable)
self.assertEqual(pool.get_variable(self.variablename), self.variable)
def test_put_variable(self):
"""Test put_variable method
"""
pool = NumerrinPool()
pool.put_variable(self.variablename, self.variable)
self.assertEqual(pool.get_variable(self.variablename), self.variable)
def test_modify_variable(self):
"""Test modify_variable method
"""
pool = NumerrinPool()
pool.put_variable(self.variablename, self.variable)
oldvar = pool.get_variable(self.variablename)
modvar = tuple([(10.0, 10.0, 10.0) for _ in oldvar])
pool.modify_variable(self.variablename, modvar)
newvar = pool.get_variable(self.variablename)
self.assertNotEqual(oldvar, newvar)
def test_delete_mesh_and_variables(self):
"""Test delete_mesh_and_variables method
"""
pool = NumerrinPool()
pool.import_mesh(self.mesh.name, self.mesh, self.boundaries)
pool.put_variable(self.variablename, self.variable)
pool.delete_mesh_and_variables(self.mesh.name)
with self.assertRaises(RuntimeError):
pool.get_variable(self.variablename)
with self.assertRaises(RuntimeError):
numerrin.meshsize(pool.ph, self.mesh.name)
def test_export_mesh(self):
"""Test export_mesh method
"""
pool = NumerrinPool()
pool.import_mesh(self.mesh.name, self.mesh, self.boundaries)
boundary_names = self.boundaries.keys()
(smesh, mmap, boundaries) = pool.export_mesh(self.mesh.name,
self.mesh.name,
boundary_names)
self.assertEqual(sum(1 for _ in smesh.iter(item_type=CUBA.POINT)),
sum(1 for _ in self.mesh.iter(item_type=CUBA.POINT)))
self.assertEqual(sum(1 for _ in smesh.iter(item_type=CUBA.FACE)),
sum(1 for _ in self.mesh.iter(item_type=CUBA.FACE)))
self.assertEqual(sum(1 for _ in smesh.iter(item_type=CUBA.CELL)),
sum(1 for _ in self.mesh.iter(item_type=CUBA.CELL)))
self.assertEqual(
set([p.coordinates for p in smesh.iter(item_type=CUBA.POINT)]),
set([p.coordinates for p in self.mesh.iter(item_type=CUBA.POINT)]))
self.assertEqual(boundaries.keys(), boundary_names)
class FoamInterfaceTestCase(unittest.TestCase):
"""Test case for OpenFOAM native interface"""
def setUp(self):
self.name = 'mesh1'
self.test_dir = 'test'
self.path = os.path.join(self.test_dir, self.name)
self.time = '0'
self.mesh = Mesh(self.name)
self.points = [
Point(
(0.0, 0.0, 0.0)),
Point(
(1.0, 0.0, 0.0)),
Point(
(1.0, 1.0, 0.0)),
Point(
(0.0, 1.0, 0.0)),
Point(
(0.0, 0.0, 1.0)),
Point(
(1.0, 0.0, 1.0)),
Point(
(1.0, 1.0, 1.0)),
Point(
(0.0, 1.0, 1.0))
]
puids = self.mesh.add(self.points)
self.faces = [
Face([puids[0], puids[3], puids[7], puids[4]],
data=DataContainer({CUBA.LABEL: 0})),
Face([puids[1], puids[2], puids[6], puids[5]],
data=DataContainer({CUBA.LABEL: 1})),
Face([puids[0], puids[1], puids[5], puids[4]],
data=DataContainer({CUBA.LABEL: 2})),
Face([puids[3], puids[2], puids[6], puids[7]],
data=DataContainer({CUBA.LABEL: 3})),
Face([puids[0], puids[1], puids[2], puids[3]],
data=DataContainer({CUBA.LABEL: 4})),
Face([puids[4], puids[5], puids[6], puids[7]],
data=DataContainer({CUBA.LABEL: 5}))
]
self.mesh.add(self.faces)
self.cells = [
Cell(puids)
]
self.puids = puids
self.mesh.add(self.cells)
self._uuidToFoamLabelAndType = {}
self._foamCellLabelToUuid = {}
self._foamFaceLabelToUuid = {}
self._foamEdgeLabelToUuid = {}
self._foamPointLabelToUuid = {}
# generate uuid mapping
label = 0
for point in self.mesh.iter(item_type=CUBA.POINT):
uid = point.uid
self._uuidToFoamLabelAndType[uid] = (label, CUBA.POINT)
self._foamPointLabelToUuid[label] = uid
label += 1
label = 0
for edge in self.mesh.iter(item_type=CUBA.EDGE):
uid = edge.uid
self._uuidToFoamLabelAndType[uid] = (label, CUBA.EDGE)
self._foamEdgeLabelToUuid[label] = uid
label += 1
label = 0
for face in self.mesh.iter(item_type=CUBA.FACE):
uid = face.uid
self._uuidToFoamLabelAndType[uid] = (label, CUBA.FACE)
self._foamFaceLabelToUuid[label] = uid
label += 1
label = 0
for cell in self.mesh.iter(item_type=CUBA.CELL):
uid = cell.uid
self._uuidToFoamLabelAndType[uid] = (label, CUBA.CELL)
self._foamCellLabelToUuid[label] = uid
label += 1
# find out boundary patches
patchNameFacesMap = OrderedDict()
self.facePoints = []
i = 0
for face in self.mesh.iter(item_type=CUBA.FACE):
boundary = 'boundary' + str(i)
i += 1
if boundary not in patchNameFacesMap:
patchNameFacesMap[boundary] = []
patchNameFacesMap[boundary].append(
self._uuidToFoamLabelAndType[face.uid][0])
# make compressed list of faces points
self.facePoints.append(len(face.points))
for puid in face.points:
self.facePoints.append(
self._uuidToFoamLabelAndType[puid][0])
# make points coordinate list
self.pointCoordinates = []
for point in self.mesh.iter(item_type=CUBA.POINT):
for coord in point.coordinates:
self.pointCoordinates.append(coord)
# make compressed list of cells points
self.cellPoints = []
for cell in self.mesh.iter(item_type=CUBA.CELL):
self.cellPoints.append(len(cell.points))
for puid in cell.points:
self.cellPoints.append(self._uuidToFoamLabelAndType[puid][0])
# make patch information
self.patchNames = []
self.patchFaces = []
self.patchTypes = []
for patchName in patchNameFacesMap:
self.patchNames.append(patchName)
self.patchFaces.append(len(patchNameFacesMap[patchName]))
for face in patchNameFacesMap[patchName]:
self.patchFaces.append(face)
self.patchTypes.append("patch")
if not self.patchNames:
error_str = 'Could not initialize with mesh {}. '
error_str += 'Mesh has not boundary face definitions.'
raise ValueError(error_str.format(self.mesh.name))
# this to have controlDict file for mesh definition
mapContent = get_dictionary_maps('simpleFoam', False)
controlDict = parse_map(mapContent['controlDict'])
foamface.init_IO(self.name, os.path.abspath(os.path.join(self.path,
os.pardir)),
controlDict)
foamface.addMesh(self.name, self.pointCoordinates,
self.cellPoints, self.facePoints,
self.patchNames, self.patchFaces,
self.patchTypes)
def tearDown(self):
if os.path.exists(self.test_dir):
shutil.rmtree(self.test_dir)
def test_add_mesh(self):
"""Test addMesh method
"""
pointCoordinates = foamface.getAllPointCoordinates(self.name)
self.assertEqual(self.pointCoordinates, pointCoordinates)
cellPoints = foamface.getAllCellPoints(self.name)
self.assertEqual(set(self.cellPoints), set(cellPoints))
facePoints = foamface.getAllFacePoints(self.name)
self.assertEqual(self.facePoints, facePoints)
patchNames = foamface.getBoundaryPatchNames(self.name)
self.assertEqual(self.patchNames, patchNames)
patchFaces = foamface.getBoundaryPatchFaces(self.name)
self.assertEqual(self.patchFaces, patchFaces)
def test_write_mesh(self):
"""Test writeMesh method
"""
foamface.writeMesh(self.name)
meshpath = os.path.join(self.test_dir, self.name,
'constant', 'polyMesh')
self.assertTrue(os.path.exists(os.path.join(meshpath, 'points')))
self.assertTrue(os.path.exists(os.path.join(meshpath, 'owner')))
self.assertTrue(os.path.exists(os.path.join(meshpath, 'neighbour')))
self.assertTrue(os.path.exists(os.path.join(meshpath, 'boundary')))
self.assertTrue(os.path.exists(os.path.join(meshpath, 'faces')))
def test_get_point_coordinates(self):
"""Test getPointCoordinates method
"""
for point in self.points:
coords = foamface.getPointCoordinates(
self.name,
self._uuidToFoamLabelAndType[point.uid][0])
self.assertEqual(point.coordinates, tuple(coords))
def test_get_face_points(self):
"""Test getFacePoints method
"""
for face in self.faces:
pointLabels = foamface.getFacePoints(
self.name,
self._uuidToFoamLabelAndType[face.uid][0])
puids = [self._foamPointLabelToUuid[lbl] for lbl in pointLabels]
self.assertEqual(puids, face.points)
def test_get_cell_points(self):
"""Test getCellPoints method
"""
for cell in self.cells:
pointLabels = foamface.getCellPoints(
self.name,
self._uuidToFoamLabelAndType[cell.uid][0])
puids = [self._foamPointLabelToUuid[lbl] for lbl in pointLabels]
self.assertEqual(set(puids), set(cell.points))
def test_get_boundary_patch_names(self):
"""Test getBoundaryPatchNames and getBoundaryPatchFaces method
"""
patchNames = foamface.getBoundaryPatchNames(self.name)
patchFaces = foamface.getBoundaryPatchFaces(self.name)
self.assertEqual(set(patchNames), set(self.patchNames))
self.assertEqual(set(patchFaces), set(self.patchFaces))
def test_get_face_count(self):
"""Test getFaceCount method
"""
nFaces = foamface.getFaceCount(self.name)
self.assertEqual(nFaces, len(self.faces))
def test_get_point_count(self):
"""Test getPointCount method
"""
nPoints = foamface.getPointCount(self.name)
self.assertEqual(nPoints, len(self.points))
def test_get_cell_count(self):
"""Test getCellCount method
"""
nCells = foamface.getCellCount(self.name)
self.assertEqual(nCells, len(self.cells))
[2, 0, 1], [3, 0, 1], [3, 1, 1], [2, 1, 1]],
'f')
cells = [
[0, 1, 2, 3], # tetra
[4, 5, 6, 7, 8, 9, 10, 11]] # hex
faces = [[2, 7, 11]]
edges = [[1, 4], [3, 8]]
container = Mesh('test')
# add points
point_iter = (Point(coordinates=point, data=DataContainer(TEMPERATURE=index))
for index, point in enumerate(points))
uids = container.add(point_iter)
# add edges
edge_iter = (Edge(points=[uids[index] for index in element],
data=DataContainer(TEMPERATURE=index + 20))
for index, element in enumerate(edges))
edge_uids = container.add(edge_iter)
# add faces
face_iter = (Face(points=[uids[index] for index in element],
data=DataContainer(TEMPERATURE=index + 30))
for index, element in enumerate(faces))
face_uids = container.add(face_iter)
# add cells
cell_iter = (Cell(points=[uids[index] for index in element],
def test_compare_mesh_datasets_not_equal(self):
# given
mesh = Mesh(name="test")
reference = Mesh(name="test_ref")
point_list = create_points_with_id()
edge_list = create_edges()
face_list = create_faces()
cell_list = create_cells()
data = create_data_container()
mesh.add(point_list)
mesh.add(edge_list)
mesh.add(face_list)
mesh.add(cell_list)
reference.add(point_list)
reference.add(edge_list)
reference.add(face_list)
reference.add(cell_list)
mesh.data = data
reference.data = data
# when/then
with self.assertRaises(AssertionError):
compare_mesh_datasets(mesh, reference, testcase=self)
# given
test_points = create_points_with_id()
mesh = Mesh(name=reference.name)
mesh.add(test_points)
mesh.add(edge_list)
mesh.add(face_list)
mesh.add(cell_list)
mesh.data = data
# when/then
with self.assertRaises(AssertionError):
compare_mesh_datasets(mesh, reference, testcase=self)
# given
test_edges = create_edges()
mesh = Mesh(name=reference.name)
mesh.add(point_list)
mesh.add(test_edges)
mesh.add(face_list)
mesh.add(cell_list)
mesh.data = data
# when/then
with self.assertRaises(AssertionError):
compare_mesh_datasets(mesh, reference, testcase=self)
# given
test_faces = create_faces()
mesh = Mesh(name=reference.name)
mesh.add(point_list)
mesh.add(edge_list)
mesh.add(test_faces)
mesh.add(cell_list)
mesh.data = data
# when/then
with self.assertRaises(AssertionError):
compare_mesh_datasets(mesh, reference, testcase=self)
# given
test_cells = create_cells()
mesh = Mesh(name=reference.name)
mesh.add(point_list)
mesh.add(edge_list)
mesh.add(face_list)
mesh.add(test_cells)
mesh.data = data
# when/then
with self.assertRaises(AssertionError):
compare_mesh_datasets(mesh, reference, testcase=self)
# given
test_data = DataContainer()
mesh = Mesh(name=reference.name)
mesh.add(point_list)
mesh.add(edge_list)
mesh.add(face_list)
mesh.add(cell_list)
mesh.data = test_data
# when/then
with self.assertRaises(AssertionError):
compare_mesh_datasets(mesh, reference, testcase=self)
class WrapperTestCase(unittest.TestCase):
"""Test case for Wrapper class"""
def setUp(self):
self.mesh = Mesh(name="mesh1")
self.points = [
Point(
(0.0, 0.0, 0.0)),
Point(
(1.0, 0.0, 0.0)),
Point(
(1.0, 1.0, 0.0)),
Point(
(0.0, 1.0, 0.0)),
Point(
(0.0, 0.0, 1.0)),
Point(
(1.0, 0.0, 1.0)),
Point(
(1.0, 1.0, 1.0)),
Point(
(0.0, 1.0, 1.0))
]
puids = self.mesh.add(self.points)
self.faces = [
Face([puids[0], puids[3], puids[7], puids[4]]),
Face([puids[1], puids[2], puids[6], puids[5]]),
Face([puids[0], puids[1], puids[5], puids[4]]),
Face([puids[3], puids[2], puids[6], puids[7]]),
Face([puids[0], puids[1], puids[2], puids[3]]),
Face([puids[4], puids[5], puids[6], puids[7]])
]
self.mesh.add(self.faces)
self.cells = [
Cell(puids)
]
self.puids = puids
self.mesh.add(self.cells)
def test_add_dataset(self):
"""Test add_dataset method
"""
wrapper = Wrapper()
wrapper.add_dataset(self.mesh)
self.assertEqual(sum(1 for _ in wrapper.iter_datasets()), 1)
def test_remove_dataset(self):
"""Test remove_dataset method
"""
wrapper = Wrapper()
wrapper.add_dataset(self.mesh)
wrapper.remove_dataset(self.mesh.name)
with self.assertRaises(KeyError):
wrapper.get_dataset(self.mesh.name)
def test_get_dataset(self):
"""Test get_dataset method
"""
wrapper = Wrapper()
wrapper.add_dataset(self.mesh)
mesh_inside_wrapper = wrapper.get_dataset(self.mesh.name)
self.assertEqual(self.mesh.name, mesh_inside_wrapper.name)
for point in self.mesh.iter(item_type=CUBA.POINT):
point_w = mesh_inside_wrapper._get_point(point.uid)
self.assertEqual(point.coordinates, point_w.coordinates)
for face in self.mesh.iter(item_type=CUBA.FACE):
face_w = mesh_inside_wrapper._get_face(face.uid)
self.assertEqual(face.points, face_w.points)
for cell in self.mesh.iter(item_type=CUBA.CELL):
cell_w = mesh_inside_wrapper._get_cell(cell.uid)
self.assertEqual(set(cell.points), set(cell_w.points))
def test_iter_datasets(self):
"""Test iter_datsets method
"""
wrapper = Wrapper()
wrapper.add_dataset(self.mesh)
mesh2 = self.mesh
mesh2.name = "mesh2"
wrapper.add_dataset(mesh2)
self.assertEqual(sum(1 for _ in wrapper.iter_datasets()), 2)
def test_multiple_meshes(self):
"""Test multiple meshes inside wrapper
"""
wrapper = Wrapper()
wrapper.add_dataset(self.mesh)
mesh2 = self.mesh
mesh2.name = "mesh2"
wrapper.add_dataset(mesh2)
mesh_inside_wrapper1 = wrapper.get_dataset(self.mesh.name)
mesh_inside_wrapper2 = wrapper.get_dataset(mesh2.name)
self.assertEqual(
sum(1 for _ in mesh_inside_wrapper1.iter(item_type=CUBA.POINT)),
sum(1 for _ in mesh_inside_wrapper2.iter(item_type=CUBA.POINT)))
def test_run_time(self):
"""Test that field variable value is changed after
consecutive calls of run method
"""
wrapper = Wrapper()
name = 'simplemesh'
corner_points = ((0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 1.0))
extrude_length = 1
nex = 3
ney = 3
nez = 1
create_quad_mesh(name, wrapper, corner_points,
extrude_length, nex, ney, nez)
wrapper.CM[CUBA.NAME] = name
wrapper.CM_extensions[CUBAExt.GE] = (CUBAExt.INCOMPRESSIBLE,
CUBAExt.LAMINAR_MODEL)
wrapper.SP[CUBA.TIME_STEP] = 1
wrapper.SP[CUBA.NUMBER_OF_TIME_STEPS] = 1
wrapper.SP[CUBA.DENSITY] = 1.0
wrapper.SP[CUBA.DYNAMIC_VISCOSITY] = 1.0
wrapper.BC[CUBA.VELOCITY] = {'inflow': ('fixedValue', (0.1, 0, 0)),
'outflow': 'zeroGradient',
'walls': ('fixedValue', (0, 0, 0)),
'frontAndBack': 'empty'}
wrapper.BC[CUBA.PRESSURE] = {'inflow': 'zeroGradient',
'outflow': ('fixedValue', 0),
'walls': 'zeroGradient',
'frontAndBack': 'empty'}
mesh_inside_wrapper = wrapper.get_dataset(name)
wrapper.run()
# sum data pointwise
old_vel = 0.0
old_pres = 0.0
for point in mesh_inside_wrapper.iter(item_type=CUBA.POINT):
velo = point.data[CUBA.VELOCITY]
old_vel += math.sqrt(velo[0]*velo[0] + velo[1]*velo[1] +
velo[2]*velo[2])
old_pres += point.data[CUBA.PRESSURE]
wrapper.SP[CUBA.DENSITY] = 5.0
wrapper.run()
# sum data pointwise
new_vel = 0.0
new_pres = 0.0
for point in mesh_inside_wrapper.iter(item_type=CUBA.POINT):
velo = point.data[CUBA.VELOCITY]
new_vel += math.sqrt(velo[0]*velo[0] + velo[1]*velo[1] +
velo[2]*velo[2])
new_pres += point.data[CUBA.PRESSURE]
self.assertNotAlmostEqual(old_vel, new_vel, 5)
self.assertNotAlmostEqual(old_pres, new_pres, 5)
[2, 0, 0], [3, 0, 0], [3, 1, 0], [2, 1, 0],
[2, 0, 1], [3, 0, 1], [3, 1, 1], [2, 1, 1]],
'f')
cells = [
[0, 1, 2, 3], # tetra
[4, 5, 6, 7, 8, 9, 10, 11]] # hex
faces = [[2, 7, 11]]
edges = [[1, 4], [3, 8]]
mesh = Mesh('mesh_example')
# add points
uids = mesh.add((Point(coordinates=point,
data=DataContainer(TEMPERATURE=index))
for index, point in enumerate(points)))
# add edges
edge_iter = (Edge(points=[uids[index] for index in element],
data=DataContainer(TEMPERATURE=index + 20))
for index, element in enumerate(edges))
edge_uids = mesh.add(edge_iter)
# add faces
face_uids = mesh.add((Face(points=[uids[index] for index in element],
data=DataContainer(TEMPERATURE=index + 30))
for index, element in enumerate(faces)))
# add cells
cell_uids = mesh.add((Cell(points=[uids[index] for index in element],
class FoamInterfaceTestCase(unittest.TestCase):
"""Test case for OpenFOAM native interface"""
def setUp(self):
self.name = 'mesh1'
self.test_dir = 'test'
self.path = os.path.join(self.test_dir, self.name)
self.time = '0'
self.mesh = Mesh(self.name)
self.points = [
Point((0.0, 0.0, 0.0)),
Point((1.0, 0.0, 0.0)),
Point((1.0, 1.0, 0.0)),
Point((0.0, 1.0, 0.0)),
Point((0.0, 0.0, 1.0)),
Point((1.0, 0.0, 1.0)),
Point((1.0, 1.0, 1.0)),
Point((0.0, 1.0, 1.0))
]
puids = self.mesh.add(self.points)
self.faces = [
Face([puids[0], puids[3], puids[7], puids[4]],
data=DataContainer({CUBA.LABEL: 0})),
Face([puids[1], puids[2], puids[6], puids[5]],
data=DataContainer({CUBA.LABEL: 1})),
Face([puids[0], puids[1], puids[5], puids[4]],
data=DataContainer({CUBA.LABEL: 2})),
Face([puids[3], puids[2], puids[6], puids[7]],
data=DataContainer({CUBA.LABEL: 3})),
Face([puids[0], puids[1], puids[2], puids[3]],
data=DataContainer({CUBA.LABEL: 4})),
Face([puids[4], puids[5], puids[6], puids[7]],
data=DataContainer({CUBA.LABEL: 5}))
]
self.mesh.add(self.faces)
self.cells = [Cell(puids)]
self.puids = puids
self.mesh.add(self.cells)
self._uuidToFoamLabelAndType = {}
self._foamCellLabelToUuid = {}
self._foamFaceLabelToUuid = {}
self._foamEdgeLabelToUuid = {}
self._foamPointLabelToUuid = {}
# generate uuid mapping
label = 0
for point in self.mesh.iter(item_type=CUBA.POINT):
uid = point.uid
self._uuidToFoamLabelAndType[uid] = (label, CUBA.POINT)
self._foamPointLabelToUuid[label] = uid
label += 1
label = 0
for edge in self.mesh.iter(item_type=CUBA.EDGE):
uid = edge.uid
self._uuidToFoamLabelAndType[uid] = (label, CUBA.EDGE)
self._foamEdgeLabelToUuid[label] = uid
label += 1
label = 0
for face in self.mesh.iter(item_type=CUBA.FACE):
uid = face.uid
self._uuidToFoamLabelAndType[uid] = (label, CUBA.FACE)
self._foamFaceLabelToUuid[label] = uid
label += 1
label = 0
for cell in self.mesh.iter(item_type=CUBA.CELL):
uid = cell.uid
self._uuidToFoamLabelAndType[uid] = (label, CUBA.CELL)
self._foamCellLabelToUuid[label] = uid
label += 1
# find out boundary patches
patchNameFacesMap = OrderedDict()
self.facePoints = []
i = 0
for face in self.mesh.iter(item_type=CUBA.FACE):
boundary = 'boundary' + str(i)
i += 1
if boundary not in patchNameFacesMap:
patchNameFacesMap[boundary] = []
patchNameFacesMap[boundary].append(
self._uuidToFoamLabelAndType[face.uid][0])
# make compressed list of faces points
self.facePoints.append(len(face.points))
for puid in face.points:
self.facePoints.append(self._uuidToFoamLabelAndType[puid][0])
# make points coordinate list
self.pointCoordinates = []
for point in self.mesh.iter(item_type=CUBA.POINT):
for coord in point.coordinates:
self.pointCoordinates.append(coord)
# make compressed list of cells points
self.cellPoints = []
for cell in self.mesh.iter(item_type=CUBA.CELL):
self.cellPoints.append(len(cell.points))
for puid in cell.points:
self.cellPoints.append(self._uuidToFoamLabelAndType[puid][0])
# make patch information
self.patchNames = []
self.patchFaces = []
self.patchTypes = []
for patchName in patchNameFacesMap:
self.patchNames.append(patchName)
self.patchFaces.append(len(patchNameFacesMap[patchName]))
for face in patchNameFacesMap[patchName]:
self.patchFaces.append(face)
self.patchTypes.append("patch")
if not self.patchNames:
error_str = 'Could not initialize with mesh {}. '
error_str += 'Mesh has not boundary face definitions.'
raise ValueError(error_str.format(self.mesh.name))
# this to have controlDict file for mesh definition
mapContent = get_dictionary_maps('simpleFoam', False)
controlDict = parse_map(mapContent['controlDict'])
foamface.init_IO(self.name,
os.path.abspath(os.path.join(self.path, os.pardir)),
controlDict)
foamface.addMesh(self.name, self.pointCoordinates, self.cellPoints,
self.facePoints, self.patchNames, self.patchFaces,
self.patchTypes)
def tearDown(self):
if os.path.exists(self.test_dir):
shutil.rmtree(self.test_dir)
def test_add_mesh(self):
"""Test addMesh method
"""
pointCoordinates = foamface.getAllPointCoordinates(self.name)
self.assertEqual(self.pointCoordinates, pointCoordinates)
cellPoints = foamface.getAllCellPoints(self.name)
self.assertEqual(set(self.cellPoints), set(cellPoints))
facePoints = foamface.getAllFacePoints(self.name)
self.assertEqual(self.facePoints, facePoints)
patchNames = foamface.getBoundaryPatchNames(self.name)
self.assertEqual(self.patchNames, patchNames)
patchFaces = foamface.getBoundaryPatchFaces(self.name)
self.assertEqual(self.patchFaces, patchFaces)
def test_write_mesh(self):
"""Test writeMesh method
"""
foamface.writeMesh(self.name)
meshpath = os.path.join(self.test_dir, self.name, 'constant',
'polyMesh')
self.assertTrue(os.path.exists(os.path.join(meshpath, 'points')))
self.assertTrue(os.path.exists(os.path.join(meshpath, 'owner')))
self.assertTrue(os.path.exists(os.path.join(meshpath, 'neighbour')))
self.assertTrue(os.path.exists(os.path.join(meshpath, 'boundary')))
self.assertTrue(os.path.exists(os.path.join(meshpath, 'faces')))
def test_get_point_coordinates(self):
"""Test getPointCoordinates method
"""
for point in self.points:
coords = foamface.getPointCoordinates(
self.name, self._uuidToFoamLabelAndType[point.uid][0])
self.assertEqual(point.coordinates, tuple(coords))
def test_get_face_points(self):
"""Test getFacePoints method
"""
for face in self.faces:
pointLabels = foamface.getFacePoints(
self.name, self._uuidToFoamLabelAndType[face.uid][0])
puids = [self._foamPointLabelToUuid[lbl] for lbl in pointLabels]
self.assertEqual(puids, face.points)
def test_get_cell_points(self):
"""Test getCellPoints method
"""
for cell in self.cells:
pointLabels = foamface.getCellPoints(
self.name, self._uuidToFoamLabelAndType[cell.uid][0])
puids = [self._foamPointLabelToUuid[lbl] for lbl in pointLabels]
self.assertEqual(set(puids), set(cell.points))
def test_get_boundary_patch_names(self):
"""Test getBoundaryPatchNames and getBoundaryPatchFaces method
"""
patchNames = foamface.getBoundaryPatchNames(self.name)
patchFaces = foamface.getBoundaryPatchFaces(self.name)
self.assertEqual(set(patchNames), set(self.patchNames))
self.assertEqual(set(patchFaces), set(self.patchFaces))
def test_get_face_count(self):
"""Test getFaceCount method
"""
nFaces = foamface.getFaceCount(self.name)
self.assertEqual(nFaces, len(self.faces))
def test_get_point_count(self):
"""Test getPointCount method
"""
nPoints = foamface.getPointCount(self.name)
self.assertEqual(nPoints, len(self.points))
def test_get_cell_count(self):
"""Test getCellCount method
"""
nCells = foamface.getCellCount(self.name)
self.assertEqual(nCells, len(self.cells))
def export_mesh(self, s_name, name, boundary_names):
""" export Numerrin mesh from pool to SimPhoNy Mesh object
Parameters
----------
s_name : str
Simphony mesh name
name : str
name of mesh
boundary_names : list str
list of boundary domain names
Return
------
(simphonyMesh, mmap) : tuple
tuple of SimPhoNy mesh object and mapping from low
level objects uuid to Numerrin label
"""
simphonyMesh = Mesh(s_name)
uuids = []
mmap = {}
meshsize = numerrin.meshsize(self.ph, name)
spoints = []
for i in range(meshsize[0]):
coord = numerrin.getnode(self.ph, name, i)
spoint = Point(coord, uid=generate_uuid())
spoints.append(spoint)
uuids.append(spoint.uid)
mmap[spoint.uid] = i
simphonyMesh.add(spoints)
if len(meshsize) > 1:
edges = []
for i in range(meshsize[1]):
plbl = numerrin.getelement(self.ph, name, 1, i, 0)
points = []
for pi in range(len(plbl)):
points.append(uuids[plbl[pi]])
ed = Edge(points, uid=generate_uuid())
edges.append(ed)
mmap[ed.uid] = i
simphonyMesh.add(edges)
if len(meshsize) > 2:
labeluidmap = {}
faces = []
for i in range(meshsize[2]):
plbl = numerrin.getelement(self.ph, name, 2, i, 0)
points = []
for pi in range(len(plbl)):
points.append(uuids[plbl[pi]])
face_renode(points)
fa = Face(points, uid=generate_uuid())
faces.append(fa)
mmap[fa.uid] = i
labeluidmap[i] = fa.uid
simphonyMesh.add(faces)
boundaries = {}
for boundary in boundary_names:
boundaries[boundary] = []
boundary_faces = numerrin.getelementnumbers(
self.ph, name + boundary)
for boundary_face in boundary_faces:
boundaries[boundary].append(labeluidmap[boundary_face])
if len(meshsize) > 3:
cells = []
for i in range(meshsize[3]):
plbl = numerrin.getelement(self.ph, name, 3, i, 0)
points = []
for pi in range(len(plbl)):
points.append(uuids[plbl[pi]])
cell_renode(points)
ce = Cell(points, uid=generate_uuid())
cells.append(ce)
mmap[ce.uid] = i
simphonyMesh.add(cells)
return (simphonyMesh, mmap, boundaries)
def export_mesh(self, s_name, name, boundary_names):
""" export Numerrin mesh from pool to SimPhoNy Mesh object
Parameters
----------
s_name : str
Simphony mesh name
name : str
name of mesh
boundary_names : list str
list of boundary domain names
Return
------
(simphonyMesh, mmap) : tuple
tuple of SimPhoNy mesh object and mapping from low
level objects uuid to Numerrin label
"""
simphonyMesh = Mesh(s_name)
uuids = []
mmap = {}
meshsize = numerrin.meshsize(self.ph, name)
spoints = []
for i in range(meshsize[0]):
coord = numerrin.getnode(self.ph, name, i)
spoint = Point(coord, uid=generate_uuid())
spoints.append(spoint)
uuids.append(spoint.uid)
mmap[spoint.uid] = i
simphonyMesh.add(spoints)
if len(meshsize) > 1:
edges = []
for i in range(meshsize[1]):
plbl = numerrin.getelement(self.ph, name, 1, i, 0)
points = []
for pi in range(len(plbl)):
points.append(uuids[plbl[pi]])
ed = Edge(points, uid=generate_uuid())
edges.append(ed)
mmap[ed.uid] = i
simphonyMesh.add(edges)
if len(meshsize) > 2:
labeluidmap = {}
faces = []
for i in range(meshsize[2]):
plbl = numerrin.getelement(self.ph, name, 2, i, 0)
points = []
for pi in range(len(plbl)):
points.append(uuids[plbl[pi]])
face_renode(points)
fa = Face(points, uid=generate_uuid())
faces.append(fa)
mmap[fa.uid] = i
labeluidmap[i] = fa.uid
simphonyMesh.add(faces)
boundaries = {}
for boundary in boundary_names:
boundaries[boundary] = []
boundary_faces = numerrin.getelementnumbers(self.ph,
name+boundary)
for boundary_face in boundary_faces:
boundaries[boundary].append(
labeluidmap[boundary_face])
if len(meshsize) > 3:
cells = []
for i in range(meshsize[3]):
plbl = numerrin.getelement(self.ph, name, 3, i, 0)
points = []
for pi in range(len(plbl)):
points.append(uuids[plbl[pi]])
cell_renode(points)
ce = Cell(points, uid=generate_uuid())
cells.append(ce)
mmap[ce.uid] = i
simphonyMesh.add(cells)
return (simphonyMesh, mmap, boundaries)
class FoamInterfaceTestCase(unittest.TestCase):
"""Test case for OpenFOAM native interface"""
def setUp(self):
print "Running FOAM interface test"
self.name = 'mesh1'
self.test_dir = 'test'
self.path = os.path.join(self.test_dir, self.name)
self.time = '0'
self.mesh = Mesh(self.name)
self.points = [
Point(
(0.0, 0.0, 0.0)),
Point(
(1.0, 0.0, 0.0)),
Point(
(1.0, 1.0, 0.0)),
Point(
(0.0, 1.0, 0.0)),
Point(
(0.0, 0.0, 1.0)),
Point(
(1.0, 0.0, 1.0)),
Point(
(1.0, 1.0, 1.0)),
Point(
(0.0, 1.0, 1.0))
]
puids = self.mesh.add(self.points)
self.faces = [
Face([puids[0], puids[3], puids[7], puids[4]]),
Face([puids[1], puids[2], puids[6], puids[5]]),
Face([puids[0], puids[1], puids[5], puids[4]]),
Face([puids[3], puids[2], puids[6], puids[7]]),
Face([puids[0], puids[1], puids[2], puids[3]]),
Face([puids[4], puids[5], puids[6], puids[7]])
]
self.mesh.add(self.faces)
self.cells = [
Cell(puids)
]
self.puids = puids
self.mesh.add(self.cells)
self._uuidToFoamLabelAndType = {}
self._foamCellLabelToUuid = {}
self._foamFaceLabelToUuid = {}
self._foamEdgeLabelToUuid = {}
self._foamPointLabelToUuid = {}
# generate uuid mapping
label = 0
for point in self.mesh.iter(item_type=CUBA.POINT):
uid = point.uid
self._uuidToFoamLabelAndType[uid] = (label, CUBA.POINT)
self._foamPointLabelToUuid[label] = uid
label += 1
label = 0
for edge in self.mesh.iter(item_type=CUBA.EDGE):
uid = edge.uid
self._uuidToFoamLabelAndType[uid] = (label, CUBA.EDGE)
self._foamEdgeLabelToUuid[label] = uid
label += 1
label = 0
for face in self.mesh.iter(item_type=CUBA.FACE):
uid = face.uid
self._uuidToFoamLabelAndType[uid] = (label, CUBA.FACE)
self._foamFaceLabelToUuid[label] = uid
label += 1
label = 0
for cell in self.mesh.iter(item_type=CUBA.CELL):
uid = cell.uid
self._uuidToFoamLabelAndType[uid] = (label, CUBA.CELL)
self._foamCellLabelToUuid[label] = uid
label += 1
# find out boundary patches
patchNameFacesMap = OrderedDict()
self.facePoints = []
i = 0
for face in self.mesh.iter(item_type=CUBA.FACE):
boundary = 'boundary' + str(i)
i += 1
if boundary not in patchNameFacesMap:
patchNameFacesMap[boundary] = []
patchNameFacesMap[boundary].append(
self._uuidToFoamLabelAndType[face.uid][0])
# make compressed list of faces points
self.facePoints.append(len(face.points))
for puid in face.points:
self.facePoints.append(self._uuidToFoamLabelAndType[puid][0])
# make points coordinate list
self.pointCoordinates = []
for point in self.mesh.iter(item_type=CUBA.POINT):
for coord in point.coordinates:
self.pointCoordinates.append(coord)
# make compressed list of cells points
self.cellPoints = []
for cell in self.mesh.iter(item_type=CUBA.CELL):
self.cellPoints.append(len(cell.points))
for puid in cell.points:
self.cellPoints.append(self._uuidToFoamLabelAndType[puid][0])
# make patch information
self.patchNames = []
self.patchFaces = []
for patchName in patchNameFacesMap:
self.patchNames.append(patchName)
self.patchFaces.append(len(patchNameFacesMap[patchName]))
for face in patchNameFacesMap[patchName]:
self.patchFaces.append(face)
if not self.patchNames:
error_str = 'Could not initialize with mesh {}. '
error_str += 'Mesh has not boundary face definitions.'
raise ValueError(error_str.format(self.mesh.name))
self.patchTypes = []
for i in range(len(self.patchNames)):
self.patchTypes.append("patch")
# this to have controlDict file for mesh definition
mapContent = foam_dicts.dictionaryMaps['pimpleFoam']
controlDict = foam_dicts.parse_map(mapContent['controlDict'])
# init objectRegistry and map to mesh name
foamface.init(self.name, controlDict)
# add mesh to objectRegisty
foamface.addMesh(self.name,
self.pointCoordinates,
self.cellPoints,
self.facePoints,
self.patchNames,
self.patchFaces,
self.patchTypes)
foamface.createDefaultFields(self.name, 'pimpleFoam', True)
def tearDown(self):
if os.path.exists(self.test_dir):
shutil.rmtree(self.test_dir)
def test_add_mesh(self):
"""Test addMesh method
"""
pointCoordinates = foamface.getAllPointCoordinates(self.name)
self.assertEqual(self.pointCoordinates, pointCoordinates)
cellPoints = foamface.getAllCellPoints(self.name)
self.assertEqual(set(self.cellPoints), set(cellPoints))
facePoints = foamface.getAllFacePoints(self.name)
self.assertEqual(self.facePoints, facePoints)
patchNames = foamface.getBoundaryPatchNames(self.name)
self.assertEqual(self.patchNames, patchNames)
patchFaces = foamface.getBoundaryPatchFaces(self.name)
self.assertEqual(self.patchFaces, patchFaces)
def test_get_point_coordinates(self):
"""Test getPointCoordinates method
"""
for point in self.points:
coords = foamface.getPointCoordinates(
self.name,
self._uuidToFoamLabelAndType[point.uid][0])
self.assertEqual(point.coordinates, tuple(coords))
def test_get_face_points(self):
"""Test getFacePoints method
"""
for face in self.faces:
pointLabels = foamface.getFacePoints(
self.name,
self._uuidToFoamLabelAndType[face.uid][0])
puids = [self._foamPointLabelToUuid[lbl] for lbl in pointLabels]
self.assertEqual(puids, face.points)
def test_get_cell_points(self):
"""Test getCellPoints method
"""
for cell in self.cells:
pointLabels = foamface.getCellPoints(
self.name,
self._uuidToFoamLabelAndType[cell.uid][0])
puids = [self._foamPointLabelToUuid[lbl] for lbl in pointLabels]
self.assertEqual(set(puids), set(cell.points))
def test_get_boundary_patch_names(self):
"""Test getBoundaryPatchNames and getBoundaryPatchFaces method
"""
patchNames = foamface.getBoundaryPatchNames(self.name)
patchFaces = foamface.getBoundaryPatchFaces(self.name)
self.assertEqual(set(patchNames), set(self.patchNames))
self.assertEqual(set(patchFaces), set(self.patchFaces))
def test_get_face_count(self):
"""Test getFaceCount method
"""
nFaces = foamface.getFaceCount(self.name)
self.assertEqual(nFaces, len(self.faces))
def test_get_point_count(self):
"""Test getPointCount method
"""
nPoints = foamface.getPointCount(self.name)
self.assertEqual(nPoints, len(self.points))
def test_get_cell_count(self):
"""Test getCellCount method
"""
nCells = foamface.getCellCount(self.name)
self.assertEqual(nCells, len(self.cells))
class NumerrinPoolTestCase(unittest.TestCase):
"""Test case for NumerrinPool class"""
def setUp(self):
self.mesh = Mesh(name="mesh1")
numerrin.initlocal("", "PYNUMERRIN_LICENSE", liccode)
self.points = [
Point(
(0.0, 0.0, 0.0),
data=DataContainer({CUBA.VELOCITY: (1, 0, 0),
CUBA.PRESSURE: 4.0})),
Point(
(1.0, 0.0, 0.0),
data=DataContainer({CUBA.VELOCITY: (1, 0, 0),
CUBA.PRESSURE: 4.0})),
Point(
(1.0, 1.0, 0.0),
data=DataContainer({CUBA.VELOCITY: (1, 0, 0),
CUBA.PRESSURE: 4.0})),
Point(
(0.0, 1.0, 0.0),
data=DataContainer({CUBA.VELOCITY: (1, 0, 0),
CUBA.PRESSURE: 4.0})),
Point(
(0.0, 0.0, 1.0),
data=DataContainer({CUBA.VELOCITY: (1, 0, 0),
CUBA.PRESSURE: 4.0})),
Point(
(1.0, 0.0, 1.0),
data=DataContainer({CUBA.VELOCITY: (1, 0, 0),
CUBA.PRESSURE: 4.0})),
Point(
(1.0, 1.0, 1.0),
data=DataContainer({CUBA.VELOCITY: (1, 0, 0),
CUBA.PRESSURE: 4.0})),
Point(
(0.0, 1.0, 1.0),
data=DataContainer({CUBA.VELOCITY: (1, 0, 0),
CUBA.PRESSURE: 4.0}))
]
puids = self.mesh.add(self.points)
self.faces = [
Face([puids[0], puids[3], puids[7], puids[4]],
data=DataContainer({CUBA.LABEL: 0})),
Face([puids[1], puids[2], puids[6], puids[5]],
data=DataContainer({CUBA.LABEL: 1})),
Face([puids[0], puids[1], puids[5], puids[4]],
data=DataContainer({CUBA.LABEL: 2})),
Face([puids[3], puids[2], puids[6], puids[7]],
data=DataContainer({CUBA.LABEL: 3})),
Face([puids[0], puids[1], puids[2], puids[3]],
data=DataContainer({CUBA.LABEL: 4})),
Face([puids[4], puids[5], puids[6], puids[7]],
data=DataContainer({CUBA.LABEL: 5}))
]
self.edge = Edge([puids[0], puids[3]])
self.mesh.add(self.faces)
self.cells = [
Cell(puids)
]
self.puids = puids
self.mesh.add(self.cells)
self.variablename = self.mesh.name + "Velocity"
self.variable = tuple([(0.0, 0.0, 0.0) for _ in self.points])
self.boundaries = {}
for i in range(6):
self.boundaries['boundary'+str(i)] = [self.faces[i].uid]
def test_import_mesh(self):
"""Test import_mesh method
"""
pool = NumerrinPool()
pool.import_mesh(self.mesh.name, self.mesh, self.boundaries)
self.assertEqual(numerrin.meshsize(pool.ph, self.mesh.name)[0],
len(self.points))
self.assertEqual(numerrin.meshsize(pool.ph, self.mesh.name)[2],
len(self.faces))
self.assertEqual(numerrin.meshsize(pool.ph, self.mesh.name)[3],
len(self.cells))
def test_clear(self):
"""Test clear method
"""
pool = NumerrinPool()
pool.import_mesh(self.mesh.name, self.mesh, self.boundaries)
pool.clear()
with self.assertRaises(RuntimeError):
numerrin.meshsize(pool.ph, self.mesh.name)
def test_variable_type(self):
"""Test variable_type method
"""
pool = NumerrinPool()
pool.import_mesh(self.mesh.name, self.mesh, self.boundaries)
self.assertEqual(pool.variable_type(self.mesh.name), "Mesh")
def test_variable_rank(self):
"""Test variable_rank method
"""
pool = NumerrinPool()
pool.put_variable(self.variablename, self.variable)
self.assertEqual(pool.variable_rank(self.variablename), 2)
def test_get_variable(self):
"""Test get_variable method
"""
pool = NumerrinPool()
pool.put_variable(self.variablename, self.variable)
self.assertEqual(pool.get_variable(self.variablename), self.variable)
def test_put_variable(self):
"""Test put_variable method
"""
pool = NumerrinPool()
pool.put_variable(self.variablename, self.variable)
self.assertEqual(pool.get_variable(self.variablename), self.variable)
def test_modify_variable(self):
"""Test modify_variable method
"""
pool = NumerrinPool()
pool.put_variable(self.variablename, self.variable)
oldvar = pool.get_variable(self.variablename)
modvar = tuple([(10.0, 10.0, 10.0) for _ in oldvar])
pool.modify_variable(self.variablename, modvar)
newvar = pool.get_variable(self.variablename)
self.assertNotEqual(oldvar, newvar)
def test_delete_mesh_and_variables(self):
"""Test delete_mesh_and_variables method
"""
pool = NumerrinPool()
pool.import_mesh(self.mesh.name, self.mesh, self.boundaries)
pool.put_variable(self.variablename, self.variable)
pool.delete_mesh_and_variables(self.mesh.name)
with self.assertRaises(RuntimeError):
pool.get_variable(self.variablename)
with self.assertRaises(RuntimeError):
numerrin.meshsize(pool.ph, self.mesh.name)
def test_export_mesh(self):
"""Test export_mesh method
"""
pool = NumerrinPool()
pool.import_mesh(self.mesh.name, self.mesh, self.boundaries)
boundary_names = self.boundaries.keys()
(smesh, mmap, boundaries) = pool.export_mesh(self.mesh.name,
self.mesh.name,
boundary_names)
self.assertEqual(sum(1 for _ in smesh.iter(item_type=CUBA.POINT)),
sum(1 for _ in self.mesh.iter(item_type=CUBA.POINT)))
self.assertEqual(sum(1 for _ in smesh.iter(item_type=CUBA.FACE)),
sum(1 for _ in self.mesh.iter(item_type=CUBA.FACE)))
self.assertEqual(sum(1 for _ in smesh.iter(item_type=CUBA.CELL)),
sum(1 for _ in self.mesh.iter(item_type=CUBA.CELL)))
self.assertEqual(set([p.coordinates
for p in smesh.iter(item_type=CUBA.POINT)]),
set([p.coordinates
for p in self.mesh.iter(item_type=CUBA.POINT)]))
self.assertEqual(boundaries.keys(), boundary_names)
def test_compare_mesh_datasets_equal(self):
# given
mesh = Mesh(name="test")
reference = Mesh(name="test")
point_list = create_points_with_id()
edge_list = create_edges()
face_list = create_faces()
cell_list = create_cells()
data = DataContainer()
mesh.add(point_list)
mesh.add(edge_list)
mesh.add(face_list)
mesh.add(cell_list)
reference.add(point_list)
reference.add(edge_list)
reference.add(face_list)
reference.add(cell_list)
mesh.data = data
reference.data = data
# this should pass without problems
compare_mesh_datasets(mesh, reference, testcase=self)
def test_compare_mesh_datasets_equal(self):
# given
mesh = Mesh(name="test")
reference = Mesh(name="test")
point_list = create_points_with_id()
edge_list = create_edges()
face_list = create_faces()
cell_list = create_cells()
data = DataContainer()
mesh.add(point_list)
mesh.add(edge_list)
mesh.add(face_list)
mesh.add(cell_list)
reference.add(point_list)
reference.add(edge_list)
reference.add(face_list)
reference.add(cell_list)
mesh.data = data
reference.data = data
# this should pass without problems
compare_mesh_datasets(mesh, reference, testcase=self)
def test_compare_mesh_datasets_not_equal(self):
# given
mesh = Mesh(name="test")
reference = Mesh(name="test_ref")
point_list = create_points_with_id()
edge_list = create_edges()
face_list = create_faces()
cell_list = create_cells()
data = create_data_container()
mesh.add(point_list)
mesh.add(edge_list)
mesh.add(face_list)
mesh.add(cell_list)
reference.add(point_list)
reference.add(edge_list)
reference.add(face_list)
reference.add(cell_list)
mesh.data = data
reference.data = data
# when/then
with self.assertRaises(AssertionError):
compare_mesh_datasets(mesh, reference, testcase=self)
# given
test_points = create_points_with_id()
mesh = Mesh(name=reference.name)
mesh.add(test_points)
mesh.add(edge_list)
mesh.add(face_list)
mesh.add(cell_list)
mesh.data = data
# when/then
with self.assertRaises(AssertionError):
compare_mesh_datasets(mesh, reference, testcase=self)
# given
test_edges = create_edges()
mesh = Mesh(name=reference.name)
mesh.add(point_list)
mesh.add(test_edges)
mesh.add(face_list)
mesh.add(cell_list)
mesh.data = data
# when/then
with self.assertRaises(AssertionError):
compare_mesh_datasets(mesh, reference, testcase=self)
# given
test_faces = create_faces()
mesh = Mesh(name=reference.name)
mesh.add(point_list)
mesh.add(edge_list)
mesh.add(test_faces)
mesh.add(cell_list)
mesh.data = data
# when/then
with self.assertRaises(AssertionError):
compare_mesh_datasets(mesh, reference, testcase=self)
# given
test_cells = create_cells()
mesh = Mesh(name=reference.name)
mesh.add(point_list)
mesh.add(edge_list)
mesh.add(face_list)
mesh.add(test_cells)
mesh.data = data
# when/then
with self.assertRaises(AssertionError):
compare_mesh_datasets(mesh, reference, testcase=self)
# given
test_data = DataContainer()
mesh = Mesh(name=reference.name)
mesh.add(point_list)
mesh.add(edge_list)
mesh.add(face_list)
mesh.add(cell_list)
mesh.data = test_data
# when/then
with self.assertRaises(AssertionError):
compare_mesh_datasets(mesh, reference, testcase=self)
class WrapperTestCase(unittest.TestCase):
"""Test case for Wrapper class"""
def setUp(self):
self.mesh = Mesh(name="mesh1")
self.points = [
Point((0.0, 0.0, 0.0)),
Point((1.0, 0.0, 0.0)),
Point((1.0, 1.0, 0.0)),
Point((0.0, 1.0, 0.0)),
Point((0.0, 0.0, 1.0)),
Point((1.0, 0.0, 1.0)),
Point((1.0, 1.0, 1.0)),
Point((0.0, 1.0, 1.0))
]
puids = self.mesh.add(self.points)
self.faces = [
Face([puids[0], puids[3], puids[7], puids[4]]),
Face([puids[1], puids[2], puids[6], puids[5]]),
Face([puids[0], puids[1], puids[5], puids[4]]),
Face([puids[3], puids[2], puids[6], puids[7]]),
Face([puids[0], puids[1], puids[2], puids[3]]),
Face([puids[4], puids[5], puids[6], puids[7]])
]
self.mesh.add(self.faces)
self.cells = [Cell(puids)]
self.puids = puids
self.mesh.add(self.cells)
def test_add_dataset(self):
"""Test add_dataset method
"""
wrapper = Wrapper()
wrapper.add_dataset(self.mesh)
self.assertEqual(sum(1 for _ in wrapper.iter_datasets()), 1)
def test_remove_dataset(self):
"""Test remove_dataset method
"""
wrapper = Wrapper()
wrapper.add_dataset(self.mesh)
wrapper.remove_dataset(self.mesh.name)
with self.assertRaises(KeyError):
wrapper.get_dataset(self.mesh.name)
def test_get_dataset(self):
"""Test get_dataset method
"""
wrapper = Wrapper()
wrapper.add_dataset(self.mesh)
mesh_inside_wrapper = wrapper.get_dataset(self.mesh.name)
self.assertEqual(self.mesh.name, mesh_inside_wrapper.name)
for point in self.mesh.iter(item_type=CUBA.POINT):
point_w = mesh_inside_wrapper._get_point(point.uid)
self.assertEqual(point.coordinates, point_w.coordinates)
for face in self.mesh.iter(item_type=CUBA.FACE):
face_w = mesh_inside_wrapper._get_face(face.uid)
self.assertEqual(face.points, face_w.points)
for cell in self.mesh.iter(item_type=CUBA.CELL):
cell_w = mesh_inside_wrapper._get_cell(cell.uid)
self.assertEqual(set(cell.points), set(cell_w.points))
def test_iter_datasets(self):
"""Test iter_datsets method
"""
wrapper = Wrapper()
wrapper.add_dataset(self.mesh)
mesh2 = self.mesh
mesh2.name = "mesh2"
wrapper.add_dataset(mesh2)
self.assertEqual(sum(1 for _ in wrapper.iter_datasets()), 2)
def test_multiple_meshes(self):
"""Test multiple meshes inside wrapper
"""
wrapper = Wrapper()
wrapper.add_dataset(self.mesh)
mesh2 = self.mesh
mesh2.name = "mesh2"
wrapper.add_dataset(mesh2)
mesh_inside_wrapper1 = wrapper.get_dataset(self.mesh.name)
mesh_inside_wrapper2 = wrapper.get_dataset(mesh2.name)
self.assertEqual(
sum(1 for _ in mesh_inside_wrapper1.iter(item_type=CUBA.POINT)),
sum(1 for _ in mesh_inside_wrapper2.iter(item_type=CUBA.POINT)))
def test_run_time(self):
"""Test that field variable value is changed after
consecutive calls of run method
"""
wrapper = Wrapper()
name = 'simplemesh'
corner_points = ((0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 1.0))
extrude_length = 1
nex = 3
ney = 3
nez = 1
create_quad_mesh(name, wrapper, corner_points, extrude_length, nex,
ney, nez)
wrapper.CM[CUBA.NAME] = name
wrapper.CM_extensions[CUBAExt.GE] = (CUBAExt.INCOMPRESSIBLE,
CUBAExt.LAMINAR_MODEL)
wrapper.SP[CUBA.TIME_STEP] = 1
wrapper.SP[CUBA.NUMBER_OF_TIME_STEPS] = 1
wrapper.SP[CUBA.DENSITY] = 1.0
wrapper.SP[CUBA.DYNAMIC_VISCOSITY] = 1.0
wrapper.BC[CUBA.VELOCITY] = {
'inflow': ('fixedValue', (0.1, 0, 0)),
'outflow': 'zeroGradient',
'walls': ('fixedValue', (0, 0, 0)),
'frontAndBack': 'empty'
}
wrapper.BC[CUBA.PRESSURE] = {
'inflow': 'zeroGradient',
'outflow': ('fixedValue', 0),
'walls': 'zeroGradient',
'frontAndBack': 'empty'
}
mesh_inside_wrapper = wrapper.get_dataset(name)
wrapper.run()
# sum data pointwise
old_vel = 0.0
old_pres = 0.0
for point in mesh_inside_wrapper.iter(item_type=CUBA.POINT):
velo = point.data[CUBA.VELOCITY]
old_vel += math.sqrt(velo[0] * velo[0] + velo[1] * velo[1] +
velo[2] * velo[2])
old_pres += point.data[CUBA.PRESSURE]
wrapper.SP[CUBA.DENSITY] = 5.0
wrapper.run()
# sum data pointwise
new_vel = 0.0
new_pres = 0.0
for point in mesh_inside_wrapper.iter(item_type=CUBA.POINT):
velo = point.data[CUBA.VELOCITY]
new_vel += math.sqrt(velo[0] * velo[0] + velo[1] * velo[1] +
velo[2] * velo[2])
new_pres += point.data[CUBA.PRESSURE]
self.assertNotAlmostEqual(old_vel, new_vel, 5)
self.assertNotAlmostEqual(old_pres, new_pres, 5)
