def doubleClicked(self, vobj):
if FreeCADGui.activeWorkbench().name() != 'CfdOFWorkbench':
FreeCADGui.activateWorkbench("CfdOFWorkbench")
doc = FreeCADGui.getDocument(vobj.Object.Document)
if not CfdTools.getActiveAnalysis():
analysis_obj = CfdTools.getParentAnalysisObject(self.Object)
if analysis_obj:
CfdTools.setActiveAnalysis(analysis_obj)
else:
FreeCAD.Console.PrintError(
'No Active Analysis detected from Solver object in the active Document\n'
)
if not doc.getInEdit():
if CfdTools.getActiveAnalysis().Document is FreeCAD.ActiveDocument:
if self.Object in CfdTools.getActiveAnalysis().Group:
doc.setEdit(vobj.Object.Name)
else:
FreeCAD.Console.PrintError(
'Please activate the Analysis this solver belongs to.\n'
)
else:
FreeCAD.Console.PrintError(
'Active Analysis is not in active Document\n')
else:
FreeCAD.Console.PrintError('Task dialog already active\n')
FreeCADGui.Control.showTaskView()
return True
def Activated(self):
FreeCAD.ActiveDocument.openTransaction("Create CFD mesh")
analysis_obj = CfdTools.getActiveAnalysis()
if analysis_obj:
mesh_obj = CfdTools.getMesh(analysis_obj)
if not mesh_obj:
sel = FreeCADGui.Selection.getSelection()
if len(sel) == 1:
if sel[0].isDerivedFrom("Part::Feature"):
mesh_obj_name = sel[0].Name + "_Mesh"
FreeCADGui.doCommand("from CfdOF.Mesh import CfdMesh")
FreeCADGui.doCommand("CfdMesh.makeCfdMesh('" +
mesh_obj_name + "')")
FreeCADGui.doCommand(
"App.ActiveDocument.ActiveObject.Part = App.ActiveDocument."
+ sel[0].Name)
if CfdTools.getActiveAnalysis():
FreeCADGui.doCommand("from CfdOF import CfdTools")
FreeCADGui.doCommand(
"CfdTools.getActiveAnalysis().addObject(App.ActiveDocument.ActiveObject)"
)
FreeCADGui.ActiveDocument.setEdit(
FreeCAD.ActiveDocument.ActiveObject.Name)
else:
print("ERROR: You cannot have more than one mesh object")
FreeCADGui.Selection.clearSelection()
def setEdit(self, vobj, mode):
if CfdTools.getActiveAnalysis():
from CfdOF.Solve.CfdRunnableFoam import CfdRunnableFoam
foam_runnable = CfdRunnableFoam(CfdTools.getActiveAnalysis(),
self.Object)
from CfdOF.Solve import TaskPanelCfdSolverControl
import importlib
importlib.reload(TaskPanelCfdSolverControl)
self.taskd = TaskPanelCfdSolverControl.TaskPanelCfdSolverControl(
foam_runnable)
self.taskd.obj = vobj.Object
FreeCADGui.Control.showDialog(self.taskd)
return True
def Activated(self):
is_present = False
members = CfdTools.getMesh(CfdTools.getActiveAnalysis()).Group
for i in members:
if hasattr(i, 'Proxy') and isinstance(i.Proxy,
CfdDynamicMeshRefinement):
FreeCADGui.activeDocument().setEdit(i.Name)
is_present = True
# Allow to re-create if deleted
if not is_present:
sel = FreeCADGui.Selection.getSelection()
if len(sel) == 1:
sobj = sel[0]
if len(sel) == 1 and hasattr(sobj, "Proxy") and isinstance(
sobj.Proxy, CfdMesh):
FreeCAD.ActiveDocument.openTransaction(
"Create DynamicMesh")
FreeCADGui.doCommand("")
FreeCADGui.doCommand(
"from CfdOF.Mesh import CfdDynamicMeshRefinement")
FreeCADGui.doCommand("from CfdOF import CfdTools")
FreeCADGui.doCommand(
"CfdDynamicMeshRefinement.makeCfdDynamicMeshRefinement(App.ActiveDocument.{})"
.format(sobj.Name))
FreeCADGui.ActiveDocument.setEdit(
FreeCAD.ActiveDocument.ActiveObject.Name)
FreeCADGui.Selection.clearSelection()
def __init__(self, obj):
self.obj = obj
self.analysis_obj = CfdTools.getActiveAnalysis()
self.physics_obj = CfdTools.getPhysicsModel(self.analysis_obj)
ui_path = os.path.join(CfdTools.getModulePath(), 'Gui', "TaskPanelCfdReportingFunctions.ui")
self.form = FreeCADGui.PySideUic.loadUi(ui_path)
# Function Object types
self.form.comboFunctionObjectType.addItems(CfdReportingFunction.OBJECT_NAMES)
self.form.comboFunctionObjectType.currentIndexChanged.connect(self.comboFunctionObjectTypeChanged)
self.form.inputReferencePressure.setToolTip("Reference pressure")
self.form.inputWriteFields.setToolTip("Write output fields")
self.form.inputCentreOfRotationx.setToolTip("Centre of rotation vector for moments")
self.form.inputLiftDirectionx.setToolTip("Lift direction vector")
self.form.inputDragDirectionx.setToolTip("Drag direction vector")
self.form.inputMagnitudeUInf.setToolTip("Velocity magnitude reference")
self.form.inputReferenceDensity.setToolTip("Density reference")
self.form.inputLengthRef.setToolTip("Length reference")
self.form.inputAreaRef.setToolTip("Area reference")
self.form.inputNBins.setToolTip("Number of bins")
self.form.inputDirectionx.setToolTip("Binning direction")
self.form.inputCumulative.setToolTip("Cumulative")
self.form.cb_patch_list.setToolTip("Patch (BC) group to monitor")
self.list_of_bcs = [bc.Label for bc in CfdTools.getCfdBoundaryGroup(self.analysis_obj)]
self.form.cb_patch_list.addItems(self.list_of_bcs)
self.load()
self.updateUI()
def runTest(self, dir_name, macro_names):
fccPrint('--------------- Start of CFD tests ---------------')
for m in macro_names:
macro_name = os.path.join(home_path, "Demos", dir_name, m)
fccPrint('Running {} macro {} ...'.format(dir_name, macro_name))
CfdTools.executeMacro(macro_name)
fccPrint('Writing {} case files ...'.format(dir_name))
analysis = CfdTools.getActiveAnalysis()
analysis.OutputPath = temp_dir
CfdTools.getSolver(analysis).InputCaseName = "case" + dir_name
CfdTools.getMeshObject(analysis).CaseName = "meshCase" + dir_name
self.writeCaseFiles()
self.child_instance.assertTrue(self.writer, "CfdTest of writer failed")
mesh_ref_dir = os.path.join(test_file_dir, "cases", dir_name, "meshCase")
mesh_case_dir = self.meshwriter.meshCaseDir
comparePaths(mesh_ref_dir, mesh_case_dir, self.child_instance)
ref_dir = os.path.join(test_file_dir, "cases", dir_name, "case")
case_dir = self.writer.case_folder
comparePaths(ref_dir, case_dir, self.child_instance)
#shutil.rmtree(mesh_case_dir)
#shutil.rmtree(case_dir)
fccPrint('--------------- End of CFD tests ---------------')
def doubleClicked(self, vobj):
if not CfdTools.getActiveAnalysis() == self.Object:
if FreeCADGui.activeWorkbench().name() != 'CfdOFWorkbench':
FreeCADGui.activateWorkbench("CfdOFWorkbench")
CfdTools.setActiveAnalysis(self.Object)
return True
return True
def writeCaseFiles(self):
analysis = CfdTools.getActiveAnalysis()
self.meshwriter = CfdMeshTools.CfdMeshTools(CfdTools.getMeshObject(analysis))
self.meshwriter.writeMesh()
self.writer = CfdCaseWriterFoam.CfdCaseWriterFoam(FreeCAD.ActiveDocument.CfdAnalysis)
self.writer.writeCase()
def getMeshObject(self):
analysis_obj = CfdTools.getActiveAnalysis()
mesh_obj = CfdTools.getMeshObject(analysis_obj)
if mesh_obj is None:
message = "Mesh object not found - please re-create."
QtGui.QMessageBox.critical(None, 'Missing mesh object', message)
doc = FreeCADGui.getDocument(self.obj.Document)
doc.resetEdit()
return mesh_obj
def Activated(self):
is_present = False
members = CfdTools.getActiveAnalysis().Group
for i in members:
if isinstance(i.Proxy, CfdSolverFoam):
FreeCADGui.activeDocument().setEdit(i.Name)
is_present = True
# Allowing user to re-create if CFDSolver was deleted.
if not is_present:
FreeCADGui.doCommand("from CfdOF import CfdTools")
FreeCADGui.doCommand("from CfdOF.Solve import CfdSolverFoam")
FreeCADGui.doCommand(
"CfdTools.getActiveAnalysis().addObject(CfdSolverFoam.makeCfdSolverFoam())"
)
FreeCADGui.doCommand(
"Gui.activeDocument().setEdit(App.ActiveDocument.ActiveObject.Name)"
)
def Activated(self):
FreeCAD.ActiveDocument.openTransaction(
"Initialise the internal flow variables")
isPresent = False
members = CfdTools.getActiveAnalysis().Group
for i in members:
if "InitialiseFields" in i.Name:
FreeCADGui.activeDocument().setEdit(i.Name)
isPresent = True
# Allow to re-create if deleted
if not isPresent:
FreeCADGui.doCommand("from CfdOF import CfdTools")
FreeCADGui.doCommand(
"from CfdOF.Solve import CfdInitialiseFlowField")
FreeCADGui.doCommand(
"CfdTools.getActiveAnalysis().addObject(CfdInitialiseFlowField.makeCfdInitialFlowField())"
)
FreeCADGui.ActiveDocument.setEdit(
FreeCAD.ActiveDocument.ActiveObject.Name)
def Activated(self):
FreeCAD.ActiveDocument.openTransaction(
"Choose appropriate physics model")
is_present = False
members = CfdTools.getActiveAnalysis().Group
for i in members:
if isinstance(i.Proxy, CfdPhysicsModel):
FreeCADGui.activeDocument().setEdit(i.Name)
is_present = True
# Allow to re-create if deleted
if not is_present:
FreeCADGui.doCommand("")
FreeCADGui.doCommand("from CfdOF.Solve import CfdPhysicsSelection")
FreeCADGui.doCommand("from CfdOF import CfdTools")
FreeCADGui.doCommand(
"CfdTools.getActiveAnalysis().addObject(CfdPhysicsSelection.makeCfdPhysicsSelection())"
)
FreeCADGui.ActiveDocument.setEdit(
FreeCAD.ActiveDocument.ActiveObject.Name)
def Activated(self):
FreeCAD.Console.PrintMessage("Set fluid properties \n")
FreeCAD.ActiveDocument.openTransaction("Set CfdFluidMaterialProperty")
FreeCADGui.doCommand("from CfdOF import CfdTools")
FreeCADGui.doCommand("from CfdOF.Solve import CfdFluidMaterial")
editing_existing = False
analysis_object = CfdTools.getActiveAnalysis()
if analysis_object is None:
CfdTools.cfdErrorBox("No active analysis object found")
return False
physics_model = CfdTools.getPhysicsModel(analysis_object)
if not physics_model or physics_model.Phase == 'Single':
members = analysis_object.Group
for i in members:
if isinstance(i.Proxy, CfdMaterial):
FreeCADGui.activeDocument().setEdit(i.Name)
editing_existing = True
if not editing_existing:
FreeCADGui.doCommand(
"CfdTools.getActiveAnalysis().addObject(CfdFluidMaterial.makeCfdFluidMaterial('FluidProperties'))")
FreeCADGui.ActiveDocument.setEdit(FreeCAD.ActiveDocument.ActiveObject.Name)
def __init__(self, solver_runner_obj):
ui_path = os.path.join(CfdTools.getModulePath(), 'Gui',
"TaskPanelCfdSolverControl.ui")
self.form = FreeCADGui.PySideUic.loadUi(ui_path)
self.analysis_object = CfdTools.getActiveAnalysis()
self.solver_runner = solver_runner_obj
self.solver_object = solver_runner_obj.solver
# update UI
self.console_message = ''
self.solver_object.Proxy.solver_process = CfdConsoleProcess(
finished_hook=self.solverFinished,
stdout_hook=self.gotOutputLines,
stderr_hook=self.gotErrorLines)
self.Timer = QtCore.QTimer()
self.Timer.setInterval(1000)
self.Timer.timeout.connect(self.updateText)
self.form.terminateSolver.clicked.connect(self.killSolverProcess)
self.form.terminateSolver.setEnabled(False)
self.open_paraview = QtCore.QProcess()
self.working_dir = CfdTools.getOutputPath(self.analysis_object)
self.updateUI()
# Connect Signals and Slots
self.form.pb_write_inp.clicked.connect(self.write_input_file_handler)
self.form.pb_edit_inp.clicked.connect(self.editSolverInputFile)
self.form.pb_run_solver.clicked.connect(self.runSolverProcess)
self.form.pb_paraview.clicked.connect(self.openParaview)
self.Start = time.time()
self.Timer.start()
def constructAncillaryPlotters(self):
reporting_functions = CfdTools.getReportingFunctionsGroup(
CfdTools.getActiveAnalysis())
if reporting_functions is not None:
for rf in reporting_functions:
if rf.ReportingFunctionType == "Force":
self.forces[rf.Label] = {}
if rf.Label not in self.solver.Proxy.forces_plotters:
self.solver.Proxy.forces_plotters[rf.Label] = \
TimePlot(title=rf.Label, y_label="Force [N]", is_log=False)
elif rf.ReportingFunctionType == "ForceCoefficients":
self.force_coeffs[rf.Label] = {}
if rf.Label not in self.solver.Proxy.force_coeffs_plotters:
self.solver.Proxy.force_coeffs_plotters[rf.Label] = \
TimePlot(title=rf.Label, y_label="Coefficient", is_log=False)
elif rf.ReportingFunctionType == 'Probes':
self.probes[rf.Label] = {
'field': rf.SampleFieldName,
'points': [rf.ProbePosition]
}
if rf.Label not in self.solver.Proxy.probes_plotters:
self.solver.Proxy.probes_plotters[rf.Label] = \
TimePlot(title=rf.Label, y_label=rf.SampleFieldName, is_log=False)
def __init__(self, analysis=None, solver=None):
super(CfdRunnable, self).__init__()
if analysis and isinstance(analysis.Proxy, CfdAnalysis.CfdAnalysis):
self.analysis = analysis
else:
if FreeCAD.GuiUp:
self.analysis = CfdTools.getActiveAnalysis()
self.solver = None
if solver:
self.solver = solver
else:
if analysis:
self.solver = CfdTools.getSolver(self.analysis)
if not self.solver:
FreeCAD.Console.printMessage(
"Solver object is missing from Analysis Object")
if self.analysis:
self.results_present = False
self.result_object = None
else:
raise Exception('No active analysis found')
def processRefinements(self):
""" Process mesh refinements """
mr_objs = CfdTools.getMeshRefinementObjs(self.mesh_obj)
cf_settings = self.cf_settings
cf_settings['MeshRegions'] = {}
cf_settings['BoundaryLayers'] = {}
cf_settings['InternalRegions'] = {}
snappy_settings = self.snappy_settings
snappy_settings['MeshRegions'] = {}
snappy_settings['BoundaryLayers'] = {}
snappy_settings['InternalRegions'] = {}
# Make list of all faces in meshed shape with original index
mesh_face_list = list(
zip(self.mesh_obj.Part.Shape.Faces,
range(len(self.mesh_obj.Part.Shape.Faces))))
# Make list of all boundary references
CfdTools.cfdMessage("Matching boundary patches\n")
boundary_face_list = []
bc_group = None
analysis_obj = CfdTools.getParentAnalysisObject(self.mesh_obj)
if not analysis_obj:
analysis_obj = CfdTools.getActiveAnalysis()
if analysis_obj:
bc_group = CfdTools.getCfdBoundaryGroup(analysis_obj)
for bc_id, bc_obj in enumerate(bc_group):
for ri, ref in enumerate(bc_obj.ShapeRefs):
try:
bf = CfdTools.resolveReference(ref)
except RuntimeError as re:
raise RuntimeError(
"Error processing boundary condition {}: {}".format(
bc_obj.Label, str(re)))
for si, s in enumerate(bf):
boundary_face_list += [(sf, (bc_id, ri, si))
for sf in s[0].Faces]
# Match them up to faces in the main geometry
bc_matched_faces = CfdTools.matchFaces(boundary_face_list,
mesh_face_list)
# Check for and filter duplicates
bc_match_per_shape_face = [-1] * len(mesh_face_list)
for k in range(len(bc_matched_faces)):
match = bc_matched_faces[k][1]
prev_k = bc_match_per_shape_face[match]
if prev_k >= 0:
nb, ri, si = bc_matched_faces[k][0]
nb2, ri2, si2 = bc_matched_faces[prev_k][0]
bc = bc_group[nb]
bc2 = bc_group[nb2]
CfdTools.cfdWarning(
"Boundary '{}' reference {}:{} also assigned as "
"boundary '{}' reference {}:{} - ignoring duplicate\n".
format(bc.Label, bc.ShapeRefs[ri][0].Name,
bc.ShapeRefs[ri][1][si], bc2.Label,
bc.ShapeRefs[ri][0].Name, bc.ShapeRefs[ri][1][si]))
else:
bc_match_per_shape_face[match] = k
# Match relevant mesh regions to the shape being meshed: boundary layer mesh regions for cfMesh,
# all surface mesh refinements for snappyHexMesh, and extrusion patches for all meshers.
# For cfMesh, surface mesh refinements are written as separate surfaces so need not be matched
CfdTools.cfdMessage("Matching mesh refinement regions\n")
mr_face_list = []
for mr_id, mr_obj in enumerate(mr_objs):
if mr_obj.Extrusion or (
self.mesh_obj.MeshUtility == 'cfMesh'
and not mr_obj.Internal and mr_obj.NumberLayers > 0) or (
self.mesh_obj.MeshUtility == 'snappyHexMesh'
and not mr_obj.Internal):
for ri, r in enumerate(mr_obj.ShapeRefs):
try:
bf = CfdTools.resolveReference(r)
except RuntimeError as re:
raise RuntimeError(
"Error processing mesh refinement {}: {}".format(
mr_obj.Label, str(re)))
for si, s in enumerate(bf):
mr_face_list += [(f, (mr_id, ri, si))
for f in s[0].Faces]
# Match them up to the primary geometry
mr_matched_faces = CfdTools.matchFaces(mr_face_list, mesh_face_list)
# Check for and filter duplicates
mr_match_per_shape_face = [-1] * len(mesh_face_list)
for k in range(len(mr_matched_faces)):
match = mr_matched_faces[k][1]
prev_k = mr_match_per_shape_face[match]
if prev_k >= 0:
nr, ri, si = mr_matched_faces[k][0]
nr2, ri2, si2 = mr_matched_faces[prev_k][0]
CfdTools.cfdWarning(
"Mesh refinement '{}' reference {}:{} also assigned as "
"mesh refinement '{}' reference {}:{} - ignoring duplicate\n"
.format(mr_objs[nr].Label,
mr_objs[nr].ShapeRefs[ri][0].Name,
mr_objs[nr].ShapeRefs[ri][1][si],
mr_objs[nr2].Label,
mr_objs[nr2].ShapeRefs[ri2][0].Name,
mr_objs[nr2].ShapeRefs[ri2][1][si2]))
else:
mr_match_per_shape_face[match] = k
self.patch_faces = []
self.patch_names = []
for k in range(len(bc_group) + 1):
self.patch_faces.append([])
self.patch_names.append([])
for l in range(len(mr_objs) + 1):
self.patch_faces[k].append([])
self.patch_names[k].append("patch_" + str(k) + "_" + str(l))
for i in range(len(mesh_face_list)):
k = bc_match_per_shape_face[i]
l = mr_match_per_shape_face[i]
nb = -1
nr = -1
if k >= 0:
nb, bri, bsi = bc_matched_faces[k][0]
if l >= 0:
nr, rri, ssi = mr_matched_faces[l][0]
self.patch_faces[nb + 1][nr + 1].append(i)
# For gmsh, match mesh refinement with vertices in original mesh
mr_matched_vertices = []
if self.mesh_obj.MeshUtility == 'gmsh':
# Make list of all vertices in meshed shape with original index
mesh_vertices_list = list(
zip(self.mesh_obj.Part.Shape.Vertexes,
range(len(self.mesh_obj.Part.Shape.Vertexes))))
CfdTools.cfdMessage("Matching mesh refinements\n")
mr_vertices_list = []
for mr_id, mr_obj in enumerate(mr_objs):
if not mr_obj.Internal:
for ri, r in enumerate(mr_obj.ShapeRefs):
try:
bf = CfdTools.resolveReference(r)
except RuntimeError as re:
raise RuntimeError(
"Error processing mesh refinement {}: {}".
format(mr_obj.Label, str(re)))
for si, s in enumerate(bf):
mr_vertices_list += [(v, (mr_id, ri, si))
for v in s[0].Vertexes]
mr_matched_vertices = CfdTools.matchFaces(mr_vertices_list,
mesh_vertices_list)
self.ele_length_map = {}
self.ele_node_map = {}
# For snappyHexMesh, also match surface mesh refinements to the boundary conditions, to identify boundary
# conditions on supplementary geometry defined by the surface mesh refinements
# Also matches baffles to surface mesh refinements
bc_mr_matched_faces = []
if self.mesh_obj.MeshUtility == 'snappyHexMesh':
bc_mr_matched_faces = CfdTools.matchFaces(boundary_face_list,
mr_face_list)
# Handle baffles
for bc_id, bc_obj in enumerate(bc_group):
if bc_obj.BoundaryType == 'baffle':
baffle_matches = [
m for m in bc_mr_matched_faces if m[0][0] == bc_id
]
mr_match_per_baffle_ref = []
for r in bc_obj.ShapeRefs:
mr_match_per_baffle_ref += [[-1] * len(r[1])]
for m in baffle_matches:
mr_match_per_baffle_ref[m[0][1]][m[0][2]] = m[1][0]
# For each mesh region, the refs that are part of this baffle
baffle_patch_refs = [[] for ri in range(len(mr_objs) + 1)]
for ri, mr in enumerate(mr_match_per_baffle_ref):
for si, mri in enumerate(mr_match_per_baffle_ref[ri]):
baffle_patch_refs[mri + 1].append(
(bc_obj.ShapeRefs[ri][0],
(bc_obj.ShapeRefs[ri][1][si], )))
# Write these geometries
for ri, refs in enumerate(baffle_patch_refs):
try:
shape = CfdTools.makeShapeFromReferences(refs)
except RuntimeError as re:
raise RuntimeError(
"Error processing baffle {}: {}".format(
bc_obj.Label, str(re)))
solid_name = bc_obj.Name + "_" + str(ri)
if shape:
CfdTools.cfdMessage(
"Triangulating baffle {}, section {}\n".format(
bc_obj.Label, ri))
writeSurfaceMeshFromShape(shape, self.triSurfaceDir,
solid_name, self.mesh_obj)
if ri > 0: # The parts of the baffle corresponding to a surface mesh region obj
mr_obj = mr_objs[ri - 1]
refinement_level = CfdTools.relLenToRefinementLevel(
mr_obj.RelativeLength)
edge_level = CfdTools.relLenToRefinementLevel(
mr_obj.RegionEdgeRefinement)
else: # The parts of the baffle with no refinement obj
refinement_level = 0
edge_level = 0
snappy_settings['MeshRegions'][solid_name] = {
'RefinementLevel': refinement_level,
'EdgeRefinementLevel': edge_level,
'MaxRefinementLevel': max(refinement_level,
edge_level),
'Baffle': True
}
for mr_id, mr_obj in enumerate(mr_objs):
Internal = mr_obj.Internal
mr_rellen = mr_obj.RelativeLength
if mr_rellen > 1.0:
mr_rellen = 1.0
FreeCAD.Console.PrintError(
"The mesh refinement region '{}' 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 mesh refinement region '{}' should not use a relative length smaller "
"than 0.001.\n".format(mr_obj.Name))
if self.mesh_obj.MeshUtility == 'gmsh':
# Generate element maps for gmsh
if not Internal:
mesh_vertex_idx = [
mf[1] for mf in mr_matched_vertices
if mf[0][0] == mr_id
]
self.ele_length_map[mr_obj.Name] = mr_rellen * self.clmax
self.ele_node_map[mr_obj.Name] = mesh_vertex_idx
else:
# Find any matches with boundary conditions; mark those matching baffles for removal
bc_matches = [
m for m in bc_mr_matched_faces if m[1][0] == mr_id
]
bc_match_per_mr_ref = []
for ri, r in enumerate(mr_obj.ShapeRefs):
bc_match_per_mr_ref.append([-1] * len(r[1]))
for m in bc_matches:
bc_match_per_mr_ref[m[1][1]][m[1][2]] = -2 if bc_group[
m[0][0]].BoundaryType == 'baffle' else m[0][0]
# Unmatch those in primary geometry
main_geom_matches = [
m for m in mr_matched_faces if m[0][0] == mr_id
]
for m in main_geom_matches:
bc_match_per_mr_ref[m[0][1]][m[0][2]] = -1
# For each boundary, the refs that are part of this mesh region
mr_patch_refs = [[] for ri in range(len(bc_group) + 1)]
for ri, m in enumerate(bc_match_per_mr_ref):
for si, bci in enumerate(m):
if bci > -2:
mr_patch_refs[bci + 1].append(
(mr_obj.ShapeRefs[ri][0],
(mr_obj.ShapeRefs[ri][1][si], )))
# Loop over and write the sub-sections of this mesh object
for bi in range(len(mr_patch_refs)):
if len(mr_patch_refs[bi]) and not mr_obj.Extrusion:
if bi == 0:
mr_patch_name = mr_obj.Name
else:
mr_patch_name = self.patch_names[bi][mr_id + 1]
CfdTools.cfdMessage(
"Triangulating mesh refinement region {}, section {}\n"
.format(mr_obj.Label, bi))
try:
shape = CfdTools.makeShapeFromReferences(
mr_patch_refs[bi])
except RuntimeError as re:
raise RuntimeError(
"Error processing mesh refinement region {}: {}"
.format(mr_obj.Label, str(re)))
if shape:
writeSurfaceMeshFromShape(shape,
self.triSurfaceDir,
mr_patch_name,
self.mesh_obj)
refinement_level = CfdTools.relLenToRefinementLevel(
mr_obj.RelativeLength)
if self.mesh_obj.MeshUtility == 'cfMesh':
if not Internal:
cf_settings['MeshRegions'][mr_patch_name] = {
'RefinementLevel':
refinement_level,
'RefinementThickness':
self.scale * Units.Quantity(
mr_obj.RefinementThickness).Value,
}
else:
cf_settings['InternalRegions'][mr_obj.Name] = {
'RefinementLevel':
refinement_level,
'RelativeLength':
mr_rellen * self.clmax * self.scale
}
elif self.mesh_obj.MeshUtility == 'snappyHexMesh':
if not Internal:
edge_level = CfdTools.relLenToRefinementLevel(
mr_obj.RegionEdgeRefinement)
snappy_settings['MeshRegions'][
mr_patch_name] = {
'RefinementLevel':
refinement_level,
'EdgeRefinementLevel':
edge_level,
'MaxRefinementLevel':
max(refinement_level, edge_level),
'Baffle':
False
}
else:
snappy_settings['InternalRegions'][
mr_patch_name] = {
'RefinementLevel': refinement_level
}
# In addition, for cfMesh and SnappyHesMesh, record matched boundary layer patches
if (self.mesh_obj.MeshUtility == 'cfMesh' or self.mesh_obj.MeshUtility == 'snappyHexMesh') \
and mr_obj.NumberLayers > 0 and not Internal and not mr_obj.Extrusion:
for k in range(len(self.patch_faces)):
if len(self.patch_faces[k][mr_id + 1]):
# 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))
if self.mesh_obj.MeshUtility == 'cfMesh':
cf_settings['BoundaryLayers'][self.patch_names[k][mr_id + 1]] = \
{
'NumberLayers': mr_obj.NumberLayers,
'ExpansionRatio': expratio,
'FirstLayerHeight': self.scale * Units.Quantity(mr_obj.FirstLayerHeight).Value
}
elif self.mesh_obj.MeshUtility == 'snappyHexMesh':
snappy_settings['BoundaryLayers'][self.patch_names[k][mr_id + 1]] = \
{
'NumberLayers': mr_obj.NumberLayers,
'ExpansionRatio': expratio,
# 'FinalLayerHeight': self.scale * Units.Quantity(mr_obj.FinalLayerHeight).Value
}
def IsActive(self):
sel = FreeCADGui.Selection.getSelection()
analysis = CfdTools.getActiveAnalysis()
return analysis is not None and sel and len(
sel) == 1 and sel[0].isDerivedFrom("Part::Feature")
def IsActive(self):
return CfdTools.getActiveAnalysis() is not None
def IsActive(self):
return CfdTools.getActiveAnalysis(
) is not None # Same as for boundary condition commands