def processRefinements(self):
""" Process mesh refinements """
mr_objs = CfdTools.getMeshRefinementObjs(self.mesh_obj)
if self.mesh_obj.MeshUtility == "gmsh":
# mesh regions
self.ele_length_map = {} # { 'ElementString' : element length }
self.ele_node_map = {} # { 'ElementString' : [element nodes] }
if not mr_objs:
print(' No mesh refinements')
else:
print(' Mesh refinements found - getting elements')
if self.part_obj.Shape.ShapeType == 'Compound':
# see http://forum.freecadweb.org/viewtopic.php?f=18&t=18780&start=40#p149467 and http://forum.freecadweb.org/viewtopic.php?f=18&t=18780&p=149520#p149520
err = "GMSH could return unexpected meshes for a boolean split tools Compound. It is strongly recommended to extract the shape to mesh from the Compound and use this one."
FreeCAD.Console.PrintError(err + "\n")
for mr_obj in mr_objs:
if mr_obj.RelativeLength:
if mr_obj.References:
for sub in mr_obj.References:
# Check if the shape of the mesh region is an element of the Part to mesh;
# if not try to find the element in the shape to mesh
search_ele_in_shape_to_mesh = False
ref = FreeCAD.ActiveDocument.getObject(sub[0])
if not self.part_obj.Shape.isSame(ref.Shape):
search_ele_in_shape_to_mesh = True
elems = sub[1]
if search_ele_in_shape_to_mesh:
# Try to find the element in the Shape to mesh
ele_shape = FemGeomTools.get_element(
ref, elems
) # the method getElement(element) does not return Solid elements
found_element = CfdTools.findElementInShape(
self.part_obj.Shape, ele_shape)
if found_element:
elems = found_element
else:
FreeCAD.Console.PrintError(
"One element of the meshregion " +
mr_obj.Name +
" could not be found in the Part to mesh. It will be ignored.\n"
)
elems = None
if elems:
if elems not in self.ele_length_map:
# self.ele_length_map[elems] = Units.Quantity(mr_obj.CharacteristicLength).Value
mr_rellen = mr_obj.RelativeLength
if mr_rellen > 1.0:
mr_rellen = 1.0
FreeCAD.Console.PrintError(
"The meshregion: " +
mr_obj.Name +
" should not use a relative length greater than unity.\n"
)
elif mr_rellen < 0.01:
mr_rellen = 0.01 # Relative length should not be less than 1/100 of base length
FreeCAD.Console.PrintError(
"The meshregion: " +
mr_obj.Name +
" should not use a relative length smaller than 0.01.\n"
)
self.ele_length_map[
elems] = mr_rellen * self.clmax
else:
FreeCAD.Console.PrintError(
"The element " + elems +
" of the mesh refinement " +
mr_obj.Name +
" has been added to another mesh refinement.\n"
)
else:
FreeCAD.Console.PrintError(
"The meshregion: " + mr_obj.Name +
" is not used to create the mesh because the reference list is empty.\n"
)
else:
FreeCAD.Console.PrintError(
"The meshregion: " + mr_obj.Name +
" is not used to create the mesh because the CharacteristicLength is 0.0 mm.\n"
)
for eleml in self.ele_length_map:
ele_shape = FemGeomTools.get_element(
self.part_obj, eleml
) # the method getElement(element) does not return Solid elements
ele_vertexes = FemGeomTools.get_vertexes_by_element(
self.part_obj.Shape, ele_shape)
self.ele_node_map[eleml] = ele_vertexes
else:
cf_settings = self.cf_settings
cf_settings['MeshRegions'] = {}
cf_settings['BoundaryLayers'] = {}
cf_settings['InternalRegions'] = {}
snappy_settings = self.snappy_settings
snappy_settings['MeshRegions'] = {}
snappy_settings['InternalRegions'] = {}
from collections import defaultdict
ele_meshpatch_map = defaultdict(list)
if not mr_objs:
print(' No mesh refinement')
else:
print(' Mesh refinements - getting the elements')
if "Boolean" in self.part_obj.Name:
err = "Cartesian meshes should not be generated for boolean split compounds."
FreeCAD.Console.PrintError(err + "\n")
# Make list of list of all references for their corresponding mesh object
bl_matched_faces = []
if self.mesh_obj.MeshUtility == 'cfMesh':
region_face_lists = []
for mr_id, mr_obj in enumerate(mr_objs):
region_face_lists.append([])
if mr_obj.NumberLayers > 1 and not mr_obj.Internal:
refs = mr_obj.References
for r in refs:
region_face_lists[mr_id].append(r)
CfdTools.cfdMessage("Matching refinement regions")
bl_matched_faces = CfdTools.matchFacesToTargetShape(
region_face_lists, self.mesh_obj.Part.Shape)
for mr_id, mr_obj in enumerate(mr_objs):
Internal = mr_obj.Internal
if mr_obj.RelativeLength:
# Store parameters per region
mr_rellen = mr_obj.RelativeLength
if mr_rellen > 1.0:
mr_rellen = 1.0
FreeCAD.Console.PrintError(
"The meshregion: {} should not use a relative length greater "
"than unity.\n".format(mr_obj.Name))
elif mr_rellen < 0.001:
mr_rellen = 0.001 # Relative length should not be less than 0.1% of base length
FreeCAD.Console.PrintError(
"The meshregion: {} should not use a relative length smaller "
"than 0.001.\n".format(mr_obj.Name))
if not (self.mesh_obj.MeshUtility == 'snappyHexMesh'
and mr_obj.Baffle):
fid = open(
os.path.join(self.triSurfaceDir,
mr_obj.Name + '.stl'), 'w')
snappy_mesh_region_list = []
patch_list = []
for (si, sub) in enumerate(mr_obj.References):
shape = FreeCAD.ActiveDocument.getObject(
sub[0]).Shape
elem = sub[1]
if self.mesh_obj.MeshUtility == 'snappyHexMesh' and mr_obj.Baffle:
# Save baffle references or faces individually
baffle = "{}{}{}".format(
mr_obj.Name, sub[0], elem)
fid = open(
os.path.join(self.triSurfaceDir,
baffle + ".stl"), 'w')
snappy_mesh_region_list.append(baffle)
if elem.startswith(
'Solid'
): # getElement doesn't work with solids for some reason
elt = shape.Solids[int(elem.lstrip('Solid')) -
1]
else:
elt = shape.getElement(elem)
if elt.ShapeType == 'Face' or elt.ShapeType == 'Solid':
CfdTools.cfdMessage(
"Triangulating part: {}:{} ...".format(
FreeCAD.ActiveDocument.getObject(
sub[0]).Label, sub[1]))
facemesh = MeshPart.meshFromShape(
elt,
LinearDeflection=self.mesh_obj.
STLLinearDeflection)
CfdTools.cfdMessage(" writing to file\n")
fid.write("solid {}{}{}\n".format(
mr_obj.Name, sub[0], elem))
for face in facemesh.Facets:
fid.write(" facet normal 0 0 0\n")
fid.write(" outer loop\n")
for i in range(3):
p = [
i * self.scale
for i in face.Points[i]
]
fid.write(
" vertex {} {} {}\n".format(
p[0], p[1], p[2]))
fid.write(" endloop\n")
fid.write(" endfacet\n")
fid.write("endsolid {}{}{}\n".format(
mr_obj.Name, sub[0], elem))
if self.mesh_obj.MeshUtility == 'snappyHexMesh' and mr_obj.Baffle:
fid.close()
if not (self.mesh_obj.MeshUtility == 'snappyHexMesh'
and mr_obj.Baffle):
fid.close()
if self.mesh_obj.MeshUtility == 'cfMesh' and mr_obj.NumberLayers > 1 and not Internal:
for (i, mf) in enumerate(bl_matched_faces):
for j in range(len(mf)):
if mr_id == mf[j][0]:
sfN = self.mesh_obj.ShapeFaceNames[i]
ele_meshpatch_map[mr_obj.Name].append(
sfN)
patch_list.append(sfN)
# Limit expansion ratio to greater than 1.0 and less than 1.2
expratio = mr_obj.ExpansionRatio
expratio = min(1.2, max(1.0, expratio))
cf_settings['BoundaryLayers'][
self.mesh_obj.
ShapeFaceNames[i]] = {
'NumberLayers':
mr_obj.NumberLayers,
'ExpansionRatio':
expratio,
'FirstLayerHeight':
self.scale * Units.Quantity(
mr_obj.FirstLayerHeight).
Value
}
if self.mesh_obj.MeshUtility == 'cfMesh':
if not Internal:
cf_settings['MeshRegions'][mr_obj.Name] = {
'RelativeLength':
mr_rellen * self.clmax * self.scale,
'RefinementThickness':
self.scale * Units.Quantity(
mr_obj.RefinementThickness).Value,
}
else:
cf_settings['InternalRegions'][mr_obj.Name] = {
'RelativeLength':
mr_rellen * self.clmax * self.scale
}
elif self.mesh_obj.MeshUtility == 'snappyHexMesh':
refinement_level = CfdTools.relLenToRefinementLevel(
mr_obj.RelativeLength)
if not Internal:
if not mr_obj.Baffle:
snappy_mesh_region_list.append(mr_obj.Name)
edge_level = CfdTools.relLenToRefinementLevel(
mr_obj.RegionEdgeRefinement)
for rL in range(len(snappy_mesh_region_list)):
mrName = mr_obj.Name + snappy_mesh_region_list[
rL]
snappy_settings['MeshRegions'][mrName] = {
'RegionName':
snappy_mesh_region_list[rL],
'RefinementLevel':
refinement_level,
'EdgeRefinementLevel':
edge_level,
'MaxRefinementLevel':
max(refinement_level, edge_level),
'Baffle':
mr_obj.Baffle
}
else:
snappy_settings['InternalRegions'][
mr_obj.Name] = {
'RefinementLevel': refinement_level
}
else:
FreeCAD.Console.PrintError(
"The meshregion: " + mr_obj.Name +
" is not used to create the mesh because the "
"CharacteristicLength is 0.0 mm or the reference list is empty.\n"
)
def setupPatchNames(self):
print('Populating createPatchDict to update BC names')
import CfdMeshTools
# Init in case not meshed yet
CfdMeshTools.CfdMeshTools(self.mesh_obj)
settings = self.settings
settings['createPatches'] = {}
bc_group = self.bc_group
mobj = self.mesh_obj
# Make list of list of all boundary references for their corresponding boundary
boundary_ref_lists = []
for bc_id, bc_obj in enumerate(bc_group):
boundary_ref_lists.append(bc_obj.References)
# Match them up with faces in the meshed part
matched_faces = CfdTools.matchFacesToTargetShape(
boundary_ref_lists, mobj.Part.Shape)
bc_lists = []
for bc in bc_group:
bc_lists.append([])
for i in range(len(matched_faces)):
if matched_faces[i]:
nb, bref = matched_faces[i][0]
bc_lists[nb].append(mobj.ShapeFaceNames[i])
for k in range(len(matched_faces[i]) - 1):
nb2, bref2 = matched_faces[i][k + 1]
if nb2 != nb:
cfdMessage(
"Boundary '{}' reference {}:{} also assigned as "
"boundary '{}' reference {}:{}\n".format(
bc_group[nb].Label, bref[0], bref[1],
bc_group[nb2].Label, bref2[0], bref2[1]))
for bc_id, bc_obj in enumerate(bc_group):
bcType = bc_obj.BoundaryType
bcSubType = bc_obj.BoundarySubType
patchType = CfdTools.getPatchType(bcType, bcSubType)
settings['createPatches'][bc_obj.Label] = {
'PatchNamesList':
tuple(bc_lists[bc_id]
), # Tuple used so that case writer outputs as an array
'PatchType': patchType
}
if self.mesh_obj.MeshUtility == 'snappyHexMesh':
for regionObj in CfdTools.getMeshRefinementObjs(self.mesh_obj):
if regionObj.Baffle:
settings['createPatchesFromSnappyBaffles'] = True
if settings['createPatchesFromSnappyBaffles']:
settings['createPatchesSnappyBaffles'] = {}
# TODO Still need to include an error checker in the event that
# an internal baffle is created using snappy but is not linked up
# with a baffle boundary condition (as in there is no baffle boundary condition which
# corresponds. Currently openfoam will throw a contextually
# confusing error (only that the boundary does not exist). The primary difficulty with such a checker is
# that it is possible to define a boundary face as a baffle, which will be overridden
# by the actual boundary name and therefore won't exist anymore.
for bc_id, bc_obj in enumerate(bc_group):
bcType = bc_obj.BoundaryType
if bcType == "baffle":
tempBaffleList = []
tempBaffleListSlave = []
for regionObj in self.mesh_obj.Group:
if hasattr(regionObj, "Proxy") and \
isinstance(regionObj.Proxy, CfdMeshRefinement._CfdMeshRefinement):
# print regionObj.Name
if regionObj.Baffle:
for sub in regionObj.References:
# print sub[0].Name
elems = sub[1]
elt = FreeCAD.ActiveDocument.getObject(
sub[0]).Shape.getElement(elems)
if elt.ShapeType == 'Face':
bcFacesList = bc_obj.Shape.Faces
for bf in bcFacesList:
isSameGeo = CfdTools.isSameGeometry(
bf, elt)
if isSameGeo:
tempBaffleList.append(
regionObj.Name + sub[0] +
elems)
tempBaffleListSlave.append(
regionObj.Name + sub[0] +
elems + "_slave")
settings['createPatchesSnappyBaffles'][bc_obj.Label] = {
"PatchNamesList": tuple(tempBaffleList),
"PatchNamesListSlave": tuple(tempBaffleListSlave)
}
# Add default faces
flagName = False
def_bc_list = []
for i in range(len(matched_faces)):
if not matched_faces[i]:
def_bc_list.append(mobj.ShapeFaceNames[i])
flagName = True
if flagName:
settings['createPatches']['defaultFaces'] = {
'PatchNamesList': tuple(def_bc_list),
'PatchType': "patch"
}
def get_region_data(self):
""" Mesh regions """
if self.mesh_obj.MeshUtility == "gmsh":
# mesh regions
self.ele_length_map = {} # { 'ElementString' : element length }
self.ele_node_map = {} # { 'ElementString' : [element nodes] }
if not self.mesh_obj.MeshRegionList:
print(' No mesh regions.')
else:
print(' Mesh regions, we need to get the elements.')
if self.part_obj.Shape.ShapeType == 'Compound':
# see http://forum.freecadweb.org/viewtopic.php?f=18&t=18780&start=40#p149467 and http://forum.freecadweb.org/viewtopic.php?f=18&t=18780&p=149520#p149520
err = "GMSH could return unexpected meshes for a boolean split tools Compound. It is strongly recommended to extract the shape to mesh from the Compound and use this one."
FreeCAD.Console.PrintError(err + "\n")
for mr_obj in self.mesh_obj.MeshRegionList:
if mr_obj.RelativeLength:
if mr_obj.References:
for sub in mr_obj.References:
# check if the shape of the mesh region is an element of the Part to mesh, if not try to find the element in the shape to mesh
search_ele_in_shape_to_mesh = False
ref = FreeCAD.ActiveDocument.getObject(sub[0])
if not self.part_obj.Shape.isSame(ref.Shape):
search_ele_in_shape_to_mesh = True
elems = sub[1]
if search_ele_in_shape_to_mesh:
# Try to find the element in the Shape to mesh
ele_shape = FemMeshTools.get_element(
ref, elems
) # the method getElement(element) does not return Solid elements
found_element = CfdTools.findElementInShape(
self.part_obj.Shape, ele_shape)
if found_element:
elems = found_element
else:
FreeCAD.Console.PrintError(
"One element of the meshregion " +
mr_obj.Name +
" could not be found in the Part to mesh. It will be ignored.\n"
)
elems = None
if elems:
if elems not in self.ele_length_map:
# self.ele_length_map[elems] = Units.Quantity(mr_obj.CharacteristicLength).Value
mr_rellen = mr_obj.RelativeLength
if mr_rellen > 1.0:
mr_rellen = 1.0
FreeCAD.Console.PrintError(
"The meshregion: " +
mr_obj.Name +
" should not use a relative length greater than unity.\n"
)
elif mr_rellen < 0.01:
mr_rellen = 0.01 # Relative length should not be less than 1/100 of base length
FreeCAD.Console.PrintError(
"The meshregion: " +
mr_obj.Name +
" should not use a relative length smaller than 0.01.\n"
)
self.ele_length_map[
elems] = mr_rellen * self.clmax
else:
FreeCAD.Console.PrintError(
"The element " + elems +
" of the meshregion " +
mr_obj.Name +
" has been added to another mesh region.\n"
)
else:
FreeCAD.Console.PrintError(
"The meshregion: " + mr_obj.Name +
" is not used to create the mesh because the reference list is empty.\n"
)
else:
FreeCAD.Console.PrintError(
"The meshregion: " + mr_obj.Name +
" is not used to create the mesh because the CharacteristicLength is 0.0 mm.\n"
)
for eleml in self.ele_length_map:
ele_shape = FemMeshTools.get_element(
self.part_obj, eleml
) # the method getElement(element) does not return Solid elements
ele_vertexes = FemMeshTools.get_vertexes_by_element(
self.part_obj.Shape, ele_shape)
self.ele_node_map[eleml] = ele_vertexes
else:
cf_settings = self.cf_settings
cf_settings['MeshRegions'] = {}
cf_settings['BoundaryLayers'] = {}
cf_settings['InternalRegions'] = {}
snappy_settings = self.snappy_settings
snappy_settings['MeshRegions'] = {}
snappy_settings['InternalRegions'] = {}
from collections import defaultdict
self.ele_meshpatch_map = defaultdict(list)
if not self.mesh_obj.MeshRegionList:
print(' No mesh regions.')
else:
print(' Mesh regions, we need to get the elements.')
if "Boolean" in self.part_obj.Name:
err = "Cartesian meshes should not be generated for boolean split compounds."
FreeCAD.Console.PrintError(err + "\n")
# Make list of list of all references for their corresponding mesh object
if self.mesh_obj.MeshUtility == 'cfMesh':
region_face_lists = []
for mr_id, mr_obj in enumerate(
self.mesh_obj.MeshRegionList):
region_face_lists.append([])
if mr_obj.NumberLayers > 1 and not mr_obj.Internal:
refs = mr_obj.References
for r in refs:
region_face_lists[mr_id].append(r)
matched_faces = CfdTools.matchFacesToTargetShape(
region_face_lists, self.mesh_obj.Part.Shape)
for mr_id, mr_obj in enumerate(self.mesh_obj.MeshRegionList):
try:
Internal = mr_obj.Internal
InternalRegion = mr_obj.InternalRegion
except AttributeError:
Internal = False
InternalRegion = {}
if mr_obj.RelativeLength:
# Store parameters per region
mr_rellen = mr_obj.RelativeLength
if mr_rellen > 1.0:
mr_rellen = 1.0
FreeCAD.Console.PrintError(
"The meshregion: {} should not use a relative length greater "
"than unity.\n".format(mr_obj.Name))
elif mr_rellen < 0.001:
mr_rellen = 0.001 # Relative length should not be less than 0.1% of base length
FreeCAD.Console.PrintError(
"The meshregion: {} should not use a relative length smaller "
"than 0.05.\n".format(mr_obj.Name))
tri_surface = ""
snappy_mesh_region_list = []
patch_list = []
for (si, sub) in enumerate(mr_obj.References):
elems = sub[1]
elt = FreeCAD.ActiveDocument.getObject(
sub[0]).Shape.getElement(elems)
if elt.ShapeType == 'Face':
facemesh = MeshPart.meshFromShape(
elt,
LinearDeflection=self.mesh_obj.
STLLinearDeflection)
tri_surface += "solid {}{}{}\n".format(
mr_obj.Name, sub[0], elems)
for face in facemesh.Facets:
tri_surface += " facet normal 0 0 0\n"
tri_surface += " outer loop\n"
for i in range(3):
p = [
i * self.scale
for i in face.Points[i]
]
tri_surface += " vertex {} {} {}\n".format(
p[0], p[1], p[2])
tri_surface += " endloop\n"
tri_surface += " endfacet\n"
tri_surface += "solid {}{}{}\n".format(
mr_obj.Name, sub[0], elems)
if self.mesh_obj.MeshUtility == 'snappyHexMesh' and mr_obj.Baffle:
# Save baffle references or faces individually
baffle = "{}{}{}".format(
mr_obj.Name, sub[0], elems)
fid = open(
os.path.join(self.triSurfaceDir,
baffle + ".stl"), 'w')
fid.write(tri_surface)
fid.close()
tri_surface = ""
snappy_mesh_region_list.append(baffle)
else:
FreeCAD.Console.PrintError(
"Cartesian meshes only support surface refinement.\n"
)
if self.mesh_obj.MeshUtility == 'cfMesh' or not mr_obj.Baffle:
fid = open(
os.path.join(self.triSurfaceDir,
mr_obj.Name + '.stl'), 'w')
fid.write(tri_surface)
fid.close()
if self.mesh_obj.MeshUtility == 'cfMesh' and mr_obj.NumberLayers > 1 and not Internal:
for (i, mf) in enumerate(matched_faces):
for j in range(len(mf)):
if mr_id == mf[j][0]:
sfN = self.mesh_obj.ShapeFaceNames[i]
self.ele_meshpatch_map[
mr_obj.Name].append(sfN)
patch_list.append(sfN)
# Limit expansion ratio to greater than 1.0 and less than 1.2
expratio = mr_obj.ExpansionRatio
expratio = min(1.2, max(1.0, expratio))
cf_settings['BoundaryLayers'][
self.mesh_obj.
ShapeFaceNames[i]] = {
'NumberLayers':
mr_obj.NumberLayers,
'ExpansionRatio':
expratio,
'FirstLayerHeight':
self.scale * Units.Quantity(
mr_obj.FirstLayerHeight).
Value
}
if self.mesh_obj.MeshUtility == 'cfMesh':
if not Internal:
cf_settings['MeshRegions'][mr_obj.Name] = {
'RelativeLength':
mr_rellen * self.clmax * self.scale,
'RefinementThickness':
self.scale * Units.Quantity(
mr_obj.RefinementThickness).Value,
}
else:
cf_settings['InternalRegions'][mr_obj.Name] = {
#"Internal": Internal,
'RelativeLength':
mr_rellen * self.clmax * self.scale,
"InternalRegion":
InternalRegion
}
elif self.mesh_obj.MeshUtility == 'snappyHexMesh':
if not Internal:
if not mr_obj.Baffle:
snappy_mesh_region_list.append(mr_obj.Name)
for rL in range(len(snappy_mesh_region_list)):
mrName = mr_obj.Name + snappy_mesh_region_list[
rL]
snappy_settings['MeshRegions'][mrName] = {
'RegionName':
snappy_mesh_region_list[rL],
'RefinementLevel':
mr_obj.RefinementLevel,
'EdgeRefinementLevel':
mr_obj.RegionEdgeRefinement,
'MaxRefinementLevel':
max(mr_obj.RefinementLevel,
mr_obj.RegionEdgeRefinement),
'Baffle':
mr_obj.Baffle
}
else:
minX = InternalRegion["Center"][
"x"] - InternalRegion["BoxLengths"][
"x"] / 2.0
maxX = InternalRegion["Center"][
"x"] + InternalRegion["BoxLengths"][
"x"] / 2.0
minY = InternalRegion["Center"][
"y"] - InternalRegion["BoxLengths"][
"y"] / 2.0
maxY = InternalRegion["Center"][
"y"] + InternalRegion["BoxLengths"][
"y"] / 2.0
minZ = InternalRegion["Center"][
"z"] - InternalRegion["BoxLengths"][
"z"] / 2.0
maxZ = InternalRegion["Center"][
"z"] + InternalRegion["BoxLengths"][
"z"] / 2.0
snappy_settings['InternalRegions'][
mr_obj.Name] = {
'RefinementLevel':
mr_obj.RefinementLevel,
"Type": InternalRegion["Type"],
"Center": InternalRegion["Center"],
"Radius":
InternalRegion["SphereRadius"],
"minX": minX,
"maxX": maxX,
"minY": minY,
"maxY": maxY,
"minZ": minZ,
"maxZ": maxZ
}
else:
FreeCAD.Console.PrintError(
"The meshregion: " + mr_obj.Name +
" is not used to create the mesh because the "
"CharacteristicLength is 0.0 mm or the reference list is empty.\n"
)