def read_foammesh(name, path):
"""Read mesh from OpenFoam case files.
Parameters
----------
name : str
name to give to mesh
path : str
case directory
Raises
------
Exception if some mesh from mesh names list not found
"""
mapContent = get_dictionary_maps('pimpleFoam', False)
controlDict = parse_map(mapContent['controlDict'])
foamface.init_IO(name, path, controlDict)
foamface.readMesh(name)
nPoints = foamface.getPointCount(name)
nCells = foamface.getCellCount(name)
nFaces = foamface.getFaceCount(name)
nEdges = 0
foamMesh = FoamMesh(name, {}, 'pimpleFoam')
foamMesh.generate_uuidmapping(nPoints, nEdges, nFaces, nCells)
patchNames = foamface.getBoundaryPatchNames(name)
patchFaces = foamface.getBoundaryPatchFaces(name)
boundaries = {}
i = 0
k = 0
while i < len(patchFaces):
boundaries[patchNames[k]] = []
start = i + 1
end = start + patchFaces[i]
i += 1
for j in range(start, end):
boundaries[patchNames[k]].append(
foamMesh._foamFaceLabelToUuid[patchFaces[j]])
i += 1
k += 1
foamMesh._boundaries = boundaries
return foamMesh
def read_foammesh(name, path):
"""Read mesh from OpenFoam case files.
Parameters
----------
name : str
name to give to mesh
path : str
case directory
Raises
------
Exception if some mesh from mesh names list not found
"""
mapContent = get_dictionary_maps('pimpleFoam', False)
controlDict = parse_map(mapContent['controlDict'])
foamface.init_IO(name, path, controlDict)
foamface.readMesh(name)
nPoints = foamface.getPointCount(name)
nCells = foamface.getCellCount(name)
nFaces = foamface.getFaceCount(name)
nEdges = 0
foamMesh = FoamMesh(name, {}, 'pimpleFoam')
foamMesh.generate_uuidmapping(nPoints, nEdges, nFaces, nCells)
patchNames = foamface.getBoundaryPatchNames(name)
patchFaces = foamface.getBoundaryPatchFaces(name)
boundaries = {}
i = 0
k = 0
while i < len(patchFaces):
boundaries[patchNames[k]] = []
start = i+1
end = start+patchFaces[i]
i += 1
for j in range(start, end):
boundaries[patchNames[k]].append(
foamMesh._foamFaceLabelToUuid[patchFaces[j]])
i += 1
k += 1
foamMesh._boundaries = boundaries
return foamMesh
def create_quad_mesh(path, name, corner_points, nex, ney, nez):
""" create and add mesh to engine
Parameters
----------
path : str
path to mesh parent directory
name : str
name of mesh
corner_points : list
list of 8 [x,y,z] corner points
nex : int
number of elements in x -direction
ney : int
number of elements in y -direction
nez : int
number of elements in z -direction
Return
------------
mesh : FoamMesh
created mesh
"""
case = os.path.join(path, name)
create_directories(case)
solver = 'blockMesh'
dictionary_name = 'controlDict'
full_path = os.path.join(case, 'system')
map_content = get_dictionary_maps(solver, False)
controlDict = parse_map(map_content[dictionary_name])
write_dictionary(full_path, dictionary_name, controlDict)
dictionary_name = 'fvSchemes'
controlDict = parse_map(map_content[dictionary_name])
write_dictionary(full_path, dictionary_name, controlDict)
dictionary_name = 'fvSolution'
controlDict = parse_map(map_content[dictionary_name])
write_dictionary(full_path, dictionary_name, controlDict)
dictionary_name = 'blockMeshDict'
control = map_content[dictionary_name]
dictionary_path = os.path.join('constant', 'polyMesh')
full_name = os.path.join(os.path.join(case, dictionary_path),
dictionary_name)
corners = "("
for i in range(8):
corners += str(corner_points[i]).replace(',', ' ')
corners += ")"
control['vertices'] = corners
control['blocks'] =\
'(hex (0 1 2 3 4 5 6 7) (%i %i %i) simpleGrading (1 1 1))'\
% (nex, ney, nez)
control['boundary'] =\
"""
(
walls
{
type wall;
faces
(
(3 7 6 2)
(1 5 4 0)
);
}
inlet
{
type patch;
faces
(
(0 4 7 3)
);
}
outlet
{
type patch;
faces
(
(2 6 5 1)
);
}
frontAndBack
{
type empty;
faces
(
(0 3 2 1)
(4 5 6 7)
);
}
)
"""
blockMeshDict = parse_map(control)
write_dictionary(os.path.join(case, dictionary_path), dictionary_name,
blockMeshDict)
# this to overcome bug in blockMesh case attribute
# blockMesh searches blockMeshDict -file from doubled case directory
# copy file to that directory
blockMesh_file_name = case + os.sep + full_name
if not os.path.exists(os.path.dirname(blockMesh_file_name)):
os.makedirs(os.path.dirname(blockMesh_file_name))
shutil.copy(full_name, blockMesh_file_name)
ncores = 1
solver = 'blockMesh'
runner = FoamRunner(solver, name, case, ncores)
runner.run()
return read_foammesh(name, path)
def create_block_mesh(path, name, block_mesh_dict):
""" create and add mesh to engine
Parameters
----------
path : str
path to mesh parent directory
name : str
name of mesh
block_mesh_dict : str
blockMeshDict -file as a string
Return
------------
mesh : FoamMesh
created mesh
"""
case = os.path.join(path, name)
create_directories(case)
solver = 'blockMesh'
dictionary_name = 'controlDict'
full_path = os.path.join(case, 'system')
map_content = get_dictionary_maps(solver, False)
controlDict = parse_map(map_content[dictionary_name])
write_dictionary(full_path, dictionary_name, controlDict)
dictionary_name = 'fvSchemes'
controlDict = parse_map(map_content[dictionary_name])
write_dictionary(full_path, dictionary_name, controlDict)
dictionary_name = 'fvSolution'
controlDict = parse_map(map_content[dictionary_name])
write_dictionary(full_path, dictionary_name, controlDict)
dictionary_name = 'blockMeshDict'
dictionary_path = os.path.join('constant', 'polyMesh')
full_name = os.path.join(os.path.join(case, dictionary_path),
dictionary_name)
write_dictionary(os.path.join(case, dictionary_path), dictionary_name,
block_mesh_dict)
# this to overcome bug in blockMesh case attribute
# blockMesh searches blockMeshDict -file from doubled case directory
# copy file to that directory
blockMesh_file_name = case + os.sep + full_name
if not os.path.exists(os.path.dirname(blockMesh_file_name)):
os.makedirs(os.path.dirname(blockMesh_file_name))
shutil.copy(full_name, blockMesh_file_name)
ncores = 1
solver = 'blockMesh'
runner = FoamRunner(solver, name, case, ncores)
runner.run()
return read_foammesh(name, path)
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 __init__(self, name, cuds, solver, mesh=None, path=None):
super(FoamMesh, self).__init__(name)
self._time = 0
self._uuidToFoamLabelAndType = {}
self._foamCellLabelToUuid = {}
self._foamFaceLabelToUuid = {}
self._foamEdgeLabelToUuid = {}
self._foamPointLabelToUuid = {}
self._boundaries = {}
self._foamPhaseNameToMaterial = {}
if path:
self.path = path
else:
self.path = os.path.join(tempfile.mkdtemp(), name)
if mesh:
# generate uuid mapping
if hasattr(mesh, '_get_packed_coordinate_list'):
pointCoordinates = mesh._get_packed_coordinate_list()
i = 0
label = 0
while i < len(pointCoordinates):
uid = self._generate_uuid()
self._uuidToFoamLabelAndType[uid] = (label, CUBA.POINT)
self._foamPointLabelToUuid[label] = uid
label += 1
i += 3
else:
label = 0
pointCoordinates = []
pointMap = {}
for point in mesh.iter(item_type=CUBA.POINT):
pointMap[point.uid] = label
uid = self._generate_uuid()
self._uuidToFoamLabelAndType[uid] = (label, CUBA.POINT)
self._foamPointLabelToUuid[label] = uid
for coord in point.coordinates:
pointCoordinates.append(coord)
label += 1
label = 0
for edge in mesh.iter(item_type=CUBA.EDGE):
uid = self._generate_uuid()
self._uuidToFoamLabelAndType[uid] = (label, CUBA.EDGE)
self._foamEdgeLabelToUuid[label] = uid
label += 1
faceMap = {}
if hasattr(mesh, '_get_packed_face_list'):
label = -1
facePoints = mesh._get_packed_face_list()
i = 0
while i < len(facePoints):
label += 1
n_points = facePoints[i]
i += 1 + n_points
face_uid = mesh._foamFaceLabelToUuid[label]
faceMap[face_uid] = label
uid = self._generate_uuid()
self._uuidToFoamLabelAndType[uid] = (label, CUBA.FACE)
self._foamFaceLabelToUuid[label] = uid
else:
label = 0
facePoints = []
for face in mesh.iter(item_type=CUBA.FACE):
faceMap[face.uid] = label
uid = self._generate_uuid()
self._uuidToFoamLabelAndType[uid] = (label, CUBA.FACE)
self._foamFaceLabelToUuid[label] = uid
# make compressed list of faces points
facePoints.append(len(face.points))
for puid in face.points:
facePoints.append(pointMap[puid])
label += 1
if hasattr(mesh, '_get_packed_cell_list'):
cellPoints = mesh._get_packed_cell_list()
cell_label = -1
i = 0
while i < len(cellPoints):
cell_label += 1
n_points = cellPoints[i]
i += 1
uid = self._generate_uuid()
self._uuidToFoamLabelAndType[uid] = (cell_label, CUBA.CELL)
self._foamCellLabelToUuid[cell_label] = uid
i += n_points
else:
label = 0
cellPoints = []
cellMap = {}
for cell in mesh.iter(item_type=CUBA.CELL):
uid = self._generate_uuid()
cellMap[cell.uid] = uid
self._uuidToFoamLabelAndType[uid] = (label, CUBA.CELL)
self._foamCellLabelToUuid[label] = uid
cellPoints.append(len(cell.points))
for puid in cell.points:
cellPoints.append(pointMap[puid])
label += 1
pointMap.clear()
if hasattr(mesh, '_foamPhaseNameToMaterial') and \
mesh._foamPhaseNameToMaterial:
self._foamPhaseNameToMaterial = mesh._foamPhaseNameToMaterial
elif cuds and not_empty(cuds.iter(item_type=CUBA.MATERIAL)):
materials = list(cuds.iter(item_type=CUBA.MATERIAL))
im = 0
for material in materials:
self._foamPhaseNameToMaterial[phaseNames[im]] = material
im += 1
if hasattr(mesh, '_get_cell_data_map'):
cell_data_map = mesh._get_cell_data_map()
else:
cell_data_map = {}
nCells = mesh.count_of(CUBA.CELL)
for cell in mesh.iter(item_type=CUBA.CELL):
label, _ = self._uuidToFoamLabelAndType[cellMap[cell.uid]]
for key in cell.data:
if key not in cell_data_map:
if dataTypeMap[key] == "scalar":
cell_data_map[key] = [0] * nCells
elif dataTypeMap[key] == "vector":
cell_data_map[key] = [0] * (nCells * 3)
elif dataTypeMap[key] == "tensor":
cell_data_map[key] = [0] * (nCells * 9)
if dataTypeMap[key] == "scalar":
cell_data_map[key][label] = cell.data[key]
elif dataTypeMap[key] == "vector":
for i in range(len(cell.data[key])):
k = 3 * label + i
cell_data_map[key][k] = cell.data[key][i]
elif dataTypeMap[key] == "tensor":
for i in range(len(cell.data[key])):
k = 9 * label + i
cell_data_map[key][k] = cell.data[key][i]
# make patch information
patchNames = []
patchFaces = []
if hasattr(mesh, '_boundaries'):
for patchName in mesh._boundaries:
patchNames.append(patchName)
self._boundaries[patchName] = []
patchFaces.append(len(mesh._boundaries[patchName]))
for fuid in mesh._boundaries[patchName]:
flabel = faceMap[fuid]
new_fuid = self._foamFaceLabelToUuid[flabel]
self._boundaries[patchName].append(new_fuid)
patchFaces.append(flabel)
faceMap.clear()
patchTypes = []
if cuds:
bcs = {}
for boundary in cuds.iter(item_type=CUBA.BOUNDARY):
bcs[boundary.name] = \
get_foam_boundary_condition(
boundary.condition[0], self._foamPhaseNameToMaterial,
solver)
check_boundary_names(bcs.keys(), patchNames)
for patchName in patchNames:
if patchName in bcs and bcs[patchName] == "empty":
patchTypes.append("empty")
else:
patchTypes.append("patch")
else:
for patchName in patchNames:
patchTypes.append("patch")
mapContent = get_dictionary_maps(solver, False)
controlDict = parse_map(mapContent['controlDict'])
# init objectRegistry and map to mesh name
foamface.init_IO(name, os.path.abspath(
os.path.join(self.path, os.pardir)), controlDict)
# update time
foamface.updateTime(name, self._time)
# add mesh to objectRegisty
foamface.addMesh(name, pointCoordinates, cellPoints, facePoints,
patchNames, patchFaces, patchTypes)
# create default fields
foamface.createDefaultFields(name, solver, True)
# write mesh to disk
foamface.writeMesh(name)
# copy possible cell data to time register
self.copy_cells(cell_data_map)
cell_data_map.clear()
foamface.writeFields(name)
# correct boundary face labels
patchNames = foamface.getBoundaryPatchNames(name)
patchFaces = foamface.getBoundaryPatchFaces(name)
boundaries = {}
i = 0
k = 0
while i < len(patchFaces):
boundaries[patchNames[k]] = []
start = i+1
end = start+patchFaces[i]
i += 1
for j in range(start, end):
boundaries[patchNames[k]].append(
self._foamFaceLabelToUuid[patchFaces[j]])
i += 1
k += 1
self._boundaries = boundaries
def __init__(self, name, cuds, solver, mesh=None, path=None):
super(FoamMesh, self).__init__(name)
self._time = 0
self._uuidToFoamLabelAndType = {}
self._foamCellLabelToUuid = {}
self._foamFaceLabelToUuid = {}
self._foamEdgeLabelToUuid = {}
self._foamPointLabelToUuid = {}
self._boundaries = {}
self._foamPhaseNameToMaterial = {}
if path:
self.path = path
else:
self.path = os.path.join(tempfile.mkdtemp(), name)
if mesh:
# generate uuid mapping
if hasattr(mesh, '_get_packed_coordinate_list'):
pointCoordinates = mesh._get_packed_coordinate_list()
i = 0
label = 0
while i < len(pointCoordinates):
uid = self._generate_uuid()
self._uuidToFoamLabelAndType[uid] = (label, CUBA.POINT)
self._foamPointLabelToUuid[label] = uid
label += 1
i += 3
else:
label = 0
pointCoordinates = []
pointMap = {}
for point in mesh.iter(item_type=CUBA.POINT):
pointMap[point.uid] = label
uid = self._generate_uuid()
self._uuidToFoamLabelAndType[uid] = (label, CUBA.POINT)
self._foamPointLabelToUuid[label] = uid
for coord in point.coordinates:
pointCoordinates.append(coord)
label += 1
label = 0
for edge in mesh.iter(item_type=CUBA.EDGE):
uid = self._generate_uuid()
self._uuidToFoamLabelAndType[uid] = (label, CUBA.EDGE)
self._foamEdgeLabelToUuid[label] = uid
label += 1
faceMap = {}
if hasattr(mesh, '_get_packed_face_list'):
label = -1
facePoints = mesh._get_packed_face_list()
i = 0
while i < len(facePoints):
label += 1
n_points = facePoints[i]
i += 1 + n_points
face_uid = mesh._foamFaceLabelToUuid[label]
faceMap[face_uid] = label
uid = self._generate_uuid()
self._uuidToFoamLabelAndType[uid] = (label, CUBA.FACE)
self._foamFaceLabelToUuid[label] = uid
else:
label = 0
facePoints = []
for face in mesh.iter(item_type=CUBA.FACE):
faceMap[face.uid] = label
uid = self._generate_uuid()
self._uuidToFoamLabelAndType[uid] = (label, CUBA.FACE)
self._foamFaceLabelToUuid[label] = uid
# make compressed list of faces points
facePoints.append(len(face.points))
for puid in face.points:
facePoints.append(pointMap[puid])
label += 1
if hasattr(mesh, '_get_packed_cell_list'):
cellPoints = mesh._get_packed_cell_list()
cell_label = -1
i = 0
while i < len(cellPoints):
cell_label += 1
n_points = cellPoints[i]
i += 1
uid = self._generate_uuid()
self._uuidToFoamLabelAndType[uid] = (cell_label, CUBA.CELL)
self._foamCellLabelToUuid[cell_label] = uid
i += n_points
else:
label = 0
cellPoints = []
cellMap = {}
for cell in mesh.iter(item_type=CUBA.CELL):
uid = self._generate_uuid()
cellMap[cell.uid] = uid
self._uuidToFoamLabelAndType[uid] = (label, CUBA.CELL)
self._foamCellLabelToUuid[label] = uid
cellPoints.append(len(cell.points))
for puid in cell.points:
cellPoints.append(pointMap[puid])
label += 1
pointMap.clear()
if hasattr(mesh, '_foamPhaseNameToMaterial') and \
mesh._foamPhaseNameToMaterial:
self._foamPhaseNameToMaterial = mesh._foamPhaseNameToMaterial
elif cuds and not_empty(cuds.iter(item_type=CUBA.MATERIAL)):
materials = list(cuds.iter(item_type=CUBA.MATERIAL))
im = 0
for material in materials:
self._foamPhaseNameToMaterial[phaseNames[im]] = material
im += 1
if hasattr(mesh, '_get_cell_data_map'):
cell_data_map = mesh._get_cell_data_map()
else:
cell_data_map = {}
nCells = mesh.count_of(CUBA.CELL)
for cell in mesh.iter(item_type=CUBA.CELL):
label, _ = self._uuidToFoamLabelAndType[cellMap[cell.uid]]
for key in cell.data:
if key not in cell_data_map:
if dataTypeMap[key] == "scalar":
cell_data_map[key] = [0] * nCells
elif dataTypeMap[key] == "vector":
cell_data_map[key] = [0] * (nCells * 3)
elif dataTypeMap[key] == "tensor":
cell_data_map[key] = [0] * (nCells * 9)
if dataTypeMap[key] == "scalar":
cell_data_map[key][label] = cell.data[key]
elif dataTypeMap[key] == "vector":
for i in range(len(cell.data[key])):
k = 3 * label + i
cell_data_map[key][k] = cell.data[key][i]
elif dataTypeMap[key] == "tensor":
for i in range(len(cell.data[key])):
k = 9 * label + i
cell_data_map[key][k] = cell.data[key][i]
# make patch information
patchNames = []
patchFaces = []
if hasattr(mesh, '_boundaries'):
for patchName in mesh._boundaries:
patchNames.append(patchName)
self._boundaries[patchName] = []
patchFaces.append(len(mesh._boundaries[patchName]))
for fuid in mesh._boundaries[patchName]:
flabel = faceMap[fuid]
new_fuid = self._foamFaceLabelToUuid[flabel]
self._boundaries[patchName].append(new_fuid)
patchFaces.append(flabel)
faceMap.clear()
patchTypes = []
if cuds:
bcs = {}
for boundary in cuds.iter(item_type=CUBA.BOUNDARY):
bcs[boundary.name] = \
get_foam_boundary_condition(
boundary.condition[0], self._foamPhaseNameToMaterial,
solver)
check_boundary_names(bcs.keys(), patchNames)
for patchName in patchNames:
if patchName in bcs and bcs[patchName] == "empty":
patchTypes.append("empty")
else:
patchTypes.append("patch")
else:
for patchName in patchNames:
patchTypes.append("patch")
mapContent = get_dictionary_maps(solver, False)
controlDict = parse_map(mapContent['controlDict'])
# init objectRegistry and map to mesh name
foamface.init_IO(
name, os.path.abspath(os.path.join(self.path, os.pardir)),
controlDict)
# update time
foamface.updateTime(name, self._time)
# add mesh to objectRegisty
foamface.addMesh(name, pointCoordinates, cellPoints, facePoints,
patchNames, patchFaces, patchTypes)
# create default fields
foamface.createDefaultFields(name, solver, True)
# write mesh to disk
foamface.writeMesh(name)
# copy possible cell data to time register
self.copy_cells(cell_data_map)
cell_data_map.clear()
foamface.writeFields(name)
# correct boundary face labels
patchNames = foamface.getBoundaryPatchNames(name)
patchFaces = foamface.getBoundaryPatchFaces(name)
boundaries = {}
i = 0
k = 0
while i < len(patchFaces):
boundaries[patchNames[k]] = []
start = i + 1
end = start + patchFaces[i]
i += 1
for j in range(start, end):
boundaries[patchNames[k]].append(
self._foamFaceLabelToUuid[patchFaces[j]])
i += 1
k += 1
self._boundaries = 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)