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))
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 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)
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))
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)
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)
