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)