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 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_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)
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 container_factory(self, name):
return Mesh(name=name)
def setUp(self):
self.mesh = Mesh(name="mesh1")
numerrin.initlocal("", "PYNUMERRIN_LICENSE", liccode)
self.pool = NumerrinPool()
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_points(self.points)
self.puids = puids
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_faces(self.faces)
self.cells = [Cell(puids)]
self.puids = puids
self.mesh.add_cells(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 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 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)
