def SetPostMeshingProcesses(self):
# The order set is the order of execution:
if (self.echo_level > 0):
print(
"::[fluid_post_refining_modeler]:: -START SetPostMeshingProcesses-"
)
#select mesh elements
#generate_particles = KratosPfem.GenerateNewNodes(self.main_model_part, self.MeshingParameters, self.echo_level)
#self.mesher.SetPostMeshingProcess(generate_particles)
#select mesh elements
#select_mesh_elements = KratosPfem.SelectMeshElements(self.main_model_part, self.MeshingParameters, self.echo_level)
#self.mesher.SetPostMeshingProcess(select_mesh_elements)
select_mesh_elements = KratosPfemFluid.SelectMeshElementsForFluids(
self.main_model_part, self.MeshingParameters, self.echo_level)
self.mesher.SetPostMeshingProcess(select_mesh_elements)
#rebuild elements
#rebuild_mesh_elements = KratosPfem.BuildMeshElements(self.main_model_part, self.MeshingParameters, self.echo_level)
rebuild_mesh_elements = KratosPfem.BuildMeshElements(
self.main_model_part, self.MeshingParameters, self.echo_level)
self.mesher.SetPostMeshingProcess(rebuild_mesh_elements)
#rebuild boundary
rebuild_mesh_boundary = KratosPfem.ReconstructMeshBoundary(
self.main_model_part, self.MeshingParameters, self.echo_level)
self.mesher.SetPostMeshingProcess(rebuild_mesh_boundary)
def SetPreMeshingProcesses(self):
if(self.echo_level>0):
print(self._class_prefix()+" Set pre meshing processes")
refining_parameters = self.MeshingParameters.GetRefiningParameters()
refining_options = refining_parameters.GetRefiningOptions()
#recover_volume_losses = KratosPfem.RecoverVolumeLosses(self.model_part, self.MeshingParameters, self.echo_level)
#self.mesher.SetPreMeshingProcess(recover_volume_losses)
unactive_peak_elements = False
unactive_sliver_elements = False
set_active_flag = KratosPfem.SetActiveEntities(self.main_model_part,unactive_peak_elements,unactive_sliver_elements,self.echo_level)
self.mesher.SetPreMeshingProcess(set_active_flag)
inlet_management = KratosPfem.InletManagement(self.model_part, self.MeshingParameters, self.echo_level)
self.mesher.SetPreMeshingProcess(inlet_management)
remove_mesh_nodes = KratosPfem.RemoveFluidNodes(self.model_part, self.MeshingParameters, self.echo_level)
self.mesher.SetPreMeshingProcess(remove_mesh_nodes)
if( refining_options.Is(KratosDelaunay.MesherUtilities.REFINE_INSERT_NODES) ):
generate_new_nodes = KratosPfem.InsertNewNodes(self.model_part, self.MeshingParameters, self.echo_level)
self.mesher.SetPreMeshingProcess(generate_new_nodes)
def SetPostMeshingProcesses(self):
# The order set is the order of execution:
if (self.echo_level > 0):
print(
"::[fluid_pre_refining_modeler]:: -START SetPostMeshingProcesses-"
)
refining_parameters = self.MeshingParameters.GetRefiningParameters()
refining_options = refining_parameters.GetRefiningOptions()
#select mesh elements
select_mesh_elements = KratosPfemFluid.SelectMeshElementsForFluids(
self.model_part, self.MeshingParameters, self.echo_level)
#select_mesh_elements = KratosPfem.SelectMeshElements(self.main_model_part, self.MeshingParameters, self.echo_level)
self.mesher.SetPostMeshingProcess(select_mesh_elements)
#rebuild elements
#rebuild_mesh_elements = KratosPfem.BuildMeshElements(self.main_model_part, self.MeshingParameters, self.mesh_id, self.echo_level)
#self.mesher.SetPostMeshingProcess(rebuild_mesh_elements)
if (refining_options.Is(KratosPfem.ModelerUtilities.REFINE_ADD_NODES)):
select_refine_elements = KratosPfem.SetElementsToRefineOnSize(
self.model_part, self.MeshingParameters, self.echo_level)
self.mesher.SetPostMeshingProcess(select_refine_elements)
#rebuild elements
#rebuild_mesh_elements = KratosPfem.BuildMeshElements(self.model_part, self.MeshingParameters, self.mesh_id, self.echo_level)
rebuild_mesh_elements = KratosPfem.BuildMeshElements(
self.model_part, self.MeshingParameters, self.echo_level)
self.mesher.SetPostMeshingProcess(rebuild_mesh_elements)
#rebuild boundary
rebuild_mesh_boundary = KratosPfem.BuildMeshBoundary(
self.model_part, self.MeshingParameters, self.echo_level)
self.mesher.SetPostMeshingProcess(rebuild_mesh_boundary)
def SetPreMeshingProcesses(self):
if (self.echo_level > 0):
print(self._class_prefix() + " Set pre meshing processes")
refining_parameters = self.MeshingParameters.GetRefiningParameters()
refining_options = refining_parameters.GetRefiningOptions()
#insert inlet layer (to be tested)
#insert_inlet = KratosPfem.InsertInlet(self.model_part, self.MeshingParameters, self.echo_level)
#self.mesher.SetPreMeshingProcess(insert_inlet)
#move and remove
remove_mesh_nodes = KratosPfem.RemoveFluidNodes(
self.model_part, self.MeshingParameters, self.echo_level)
self.mesher.SetPreMeshingProcess(remove_mesh_nodes)
if (refining_options.Is(
KratosDelaunay.MesherUtilities.REFINE_INSERT_NODES)):
insert_fluid_nodes = KratosPfem.InsertFluidNodes(
self.model_part, self.MeshingParameters, self.echo_level)
self.mesher.SetPreMeshingProcess(insert_fluid_nodes)
#refine elements that have all nodes in rigid boundary
refine_edge_elements = KratosPfem.RefineFluidElementsInEdges(
self.model_part, self.MeshingParameters, self.echo_level)
self.mesher.SetPreMeshingProcess(refine_edge_elements)
def SetPostMeshingProcesses(self):
# The order set is the order of execution:
refining_parameters = self.MeshingParameters.GetRefiningParameters()
refining_options = refining_parameters.GetRefiningOptions()
#select mesh elements
select_mesh_elements = KratosPfem.SelectMeshElements(self.model_part, self.MeshingParameters, self.echo_level)
self.mesher.SetPostMeshingProcess(select_mesh_elements)
if( refining_options.Is(KratosPfem.ModelerUtilities.REFINE_ADD_NODES) ):
select_refine_elements = KratosPfem.SetElementsToRefineOnSize(self.model_part, self.MeshingParameters, self.echo_level)
self.mesher.SetPostMeshingProcess(select_refine_elements)
def SetPostMeshingProcesses(self):
# The order set is the order of execution:
#print GiD mesh output for checking purposes
print_output_mesh = KratosPfem.PrintOutputMeshProcess(self.model_part, self.MeshingParameters, "output", self.echo_level)
self.mesher.SetPostMeshingProcess(print_output_mesh)
#select mesh elements
select_mesh_elements = KratosPfem.SelectMeshElements(self.model_part, self.MeshingParameters, self.echo_level)
self.mesher.SetPostMeshingProcess(select_mesh_elements)
# build contact conditions
build_contact_conditions= KratosContact.BuildContactConditions(self.model_part, self.MeshingParameters, self.echo_level)
self.mesher.SetPostMeshingProcess(build_contact_conditions)
def SetMeshingParameters(self):
# Create MeshingParameters
self.MeshingParameters = KratosPfem.MeshingParameters()
self.MeshingParameters.Initialize()
self.MeshingParameters.SetSubModelPartName(
self.settings["model_part_name"].GetString())
if (self.active_remeshing):
self.MeshingParameters.SetAlphaParameter(
self.settings["alpha_shape"].GetDouble())
self.MeshingParameters.SetOffsetFactor(
self.settings["offset_factor"].GetDouble())
self.SetInfoParameters()
self.SetTransferParameters()
self.SetRefiningParameters()
self.MeshingParameters.SetInfoParameters(self.InfoParameters)
self.MeshingParameters.SetTransferParameters(
self.TransferParameters)
self.MeshingParameters.SetRefiningParameters(
self.RefiningParameters)
def SetPostMeshingProcesses(self):
#nothing to do: only reconnection
#select mesh elements
#select_mesh_elements = KratosPfem.SelectMeshElements(self.main_model_part, self.MeshingParameters, self.echo_level)
#self.mesher.SetPostMeshingProcess(select_mesh_elements)
#rebuild elements
rebuild_mesh_elements = KratosPfem.BuildMeshElements(
self.model_part, self.MeshingParameters, self.echo_level)
self.mesher.SetPostMeshingProcess(rebuild_mesh_elements)
#rebuild boundary
rebuild_mesh_boundary = KratosPfem.ReconstructMeshBoundary(
self.model_part, self.MeshingParameters, self.echo_level)
self.mesher.SetPostMeshingProcess(rebuild_mesh_boundary)
def RemeshFluidDomains(self):
if (self.remesh_domains_active):
# if(self.contact_search):
# self.ContactTransfer()
if (self.echo_level > 1):
print("::[Remesh_fluid_domains_process]:: MESH DOMAIN...",
self.counter)
meshing_options = KratosMultiphysics.Flags()
self.modeler_utils = KratosPfem.ModelerUtilities()
meshing_options.Set(self.modeler_utils.KEEP_ISOLATED_NODES, True)
#self.model_meshing = KratosPfem.ModelMeshing(self.main_model_part, meshing_options, self.echo_level)
self.model_meshing = KratosPfemFluid.ModelMeshingForFluids(
self.main_model_part, meshing_options, self.echo_level)
self.model_meshing.ExecuteInitialize()
id = 0
for domain in self.meshing_domains:
domain.ExecuteMeshing()
self.remesh_executed = True
id += 1
self.model_meshing.ExecuteFinalize()
self.counter += 1
def GetModelManager(self):
meshing_options = KratosMultiphysics.Flags()
self.mesher_utils = KratosDelaunay.MesherUtilities()
meshing_options.Set(self.mesher_utils.KEEP_ISOLATED_NODES, True)
#retur KratosDelaunay.ModelStructure(self.main_model_part, meshing_options, self.echo_level)
return KratosPfem.FluidModelStructure(self.main_model_part,
meshing_options, self.echo_level)
def SetPreMeshingProcesses(self):
# The order set is the order of execution:
# process to refine elements / refine boundary
refine_mesh_elements = KratosPfem.SetElementNodesToRefineOnThreshold(self.model_part, self.MeshingParameters, self.echo_level)
self.mesher.SetPreMeshingProcess(refine_mesh_elements)
# process to refine boundary / contact boundary
refine_mesh_boundary = RefineMeshBoundary(self.model_part, self.RefiningParameters, self.echo_level)
self.mesher.SetPreMeshingProcess(refine_mesh_boundary)
# process to remove nodes / remove boundary
remove_mesh_nodes = KratosPfem.RemoveMeshNodes(self.model_part, self.MeshingParameters, self.echo_level)
self.mesher.SetPreMeshingProcess(remove_mesh_nodes)
def Initialize(self, dimension):
self.dimension = dimension
# set mesh modeler
if (self.dimension == 2):
self.mesher = KratosPfem.TriangularMesh2DModeler()
elif (self.dimension == 3):
self.mesher = KratosPfem.TetrahedralMesh3DModeler()
self.mesher.SetEchoLevel(self.echo_level)
self.mesher.SetMeshingParameters(self.MeshingParameters)
self.SetPreMeshingProcesses()
self.SetPostMeshingProcesses()
self.mesher.Initialize()
def SetRefiningParameters(self): #no refine in the contact domain
# Create RefiningParameters
self.RefiningParameters = KratosPfem.RefiningParameters()
self.RefiningParameters.Initialize()
# parameters
self.RefiningParameters.SetAlphaParameter(self.settings["alpha_shape"].GetDouble())
def ExecuteInitialize(self):
# set model part
self.model_part = self.model[
self.settings["model_part_name"].GetString()]
self.ManageNodesProcess = KratosPfem.ManageIsolatedNodesProcess(
self.model_part)
def SetTransferParameters(self):
# Create TransferParameters
self.TransferParameters = KratosPfem.TransferParameters()
transfer_variables = self.settings["elemental_variables_to_transfer"]
#for variable in transfer_variables:
# self.TransferParameters.SetVariable( KratosMultiphysics.KratosGlobals.GetVariable( variable.GetString() ) )
for i in range(0, transfer_variables.size() ):
self.TransferParameters.SetVariable(KratosMultiphysics.KratosGlobals.GetVariable(transfer_variables[i].GetString()))
def ExecuteInitialize(self):
# set model part
self.model_part = self.model[self.settings["model_part_name"].GetString()]
echo_level = 0;
self.VolumeRecoveryProcess = KratosPfem.RecoverVolumeLosses(self.model_part, echo_level)
self.VolumeRecoveryProcess.ExecuteInitialize()
def SetPreMeshingProcesses(self):
# process to refine elements /refine boundary
refine_mesh_elements = KratosPfem.SetElementNodesToRefineOnThreshold(self.model_part, self.MeshingParameters, self.echo_level)
self.mesher.SetPreMeshingProcess(refine_mesh_elements)
refine_edge_elements = KratosPfem.SetElementEdgesToRefine(self.model_part,self.MeshingParameters,self.echo_level)
self.mesher.SetPreMeshingProcess(refine_edge_elements)
refine_mesh_boundary = KratosPfem.RefineMeshBoundary(self.model_part, self.MeshingParameters, self.echo_level)
self.mesher.SetPreMeshingProcess(refine_mesh_boundary)
# process to remove nodes / remove boundary
remove_mesh_nodes = KratosPfem.RemoveMeshNodes(self.model_part, self.MeshingParameters, self.echo_level)
self.mesher.SetPreMeshingProcess(remove_mesh_nodes)
def Check(self):
# set modeler utilities
self.modeler_utils = KratosPfem.ModelerUtilities()
# set the domain labels to mesh modeler
critical_mesh_size = self.settings["refining_parameters"]["critical_size"].GetDouble()
critical_radius = self.modeler_utils.CheckCriticalRadius(self.main_model_part,critical_mesh_size,self.mesh_id)
print(" CriticalRadius ", critical_radius)
def SetPostMeshingProcesses(self):
# The order set is the order of execution:
#generate new particles
generate_particles = KratosPfem.GenerateNewNodes(self.model_part, self.MeshingParameters, self.echo_level)
self.mesher.SetPostMeshingProcess(generate_particles)
#select mesh elements
select_mesh_elements = KratosPfem.SelectMeshElements(self.model_part, self.MeshingParameters, self.echo_level)
self.mesher.SetPostMeshingProcess(select_mesh_elements)
#rebuild elements
rebuild_mesh_elements = KratosPfem.BuildMeshElements(self.model_part, self.MeshingParameters, self.echo_level)
self.mesher.SetPostMeshingProcess(rebuild_mesh_elements)
#rebuild boundary
rebuild_mesh_boundary = KratosPfem.BuildMeshBoundary(self.model_part, self.MeshingParameters, self.echo_level)
self.mesher.SetPostMeshingProcess(rebuild_mesh_boundary)
def BuildMeshBoundaryForFluids(self):
# set building options:
# define building utility
model_part_name = self.settings["model_part_name"].GetString()
skin_build = KratosPfem.BuildModelPartBoundary(self.main_model_part, model_part_name, self.echo_level)
# execute building:
skin_build.Execute()
def ExecuteInitialize(self):
# set model part
self.model_part = self.model[
self.settings["model_part_name"].GetString()]
self.settings.RemoveValue("model_part_name")
self.AssignPropertiesProcess = KratosPfem.AssignPropertiesToNodes(
self.model_part, self.settings)
self.AssignPropertiesProcess.ExecuteInitialize()
def SearchElementNeighbours(self):
# set search options:
number_of_avg_elems = 10
# define search utility
elemental_neighbour_search = KratosPfem.ElementalNeighboursSearch(self.model_part, self.dimension, self.echo_level, number_of_avg_elems)
# execute search:
elemental_neighbour_search.Execute()
print("::[Modeler_Utility]:: Elemental Search executed ")
def BuildMeshBoundary(self):
print("::[Modeler_Utility]:: Build Mesh Boundary ")
# set building options:
# define building utility
# skin_build = BuildMeshBoundary(self.model_part, self.dimension, self.echo_level)
skin_build = KratosPfem.BuildMeshBoundary(self.model_part, self.echo_level)
# execute building:
skin_build.Execute()
print("::[Modeler_Utility]:: Mesh Boundary Build executed ")
def ComputeBoundaryNormals(self):
# define calculation utility
# normals_calculation = BoundaryNormalsCalculation()
normals_calculation = KratosPfem.BoundaryNormalsCalculation()
# execute calculation:
#(scaled normals)
normals_calculation.CalculateWeightedBoundaryNormals(self.model_part, self.echo_level)
#(unit normals)
# normals_calculation.CalculateUnitBoundaryNormals(model_part, self.echo_level)
print("::[Modeler_Utility]:: Boundary Normals computed ")
def SearchNodeNeighbours(self):
# set search options:
number_of_avg_elems = 10
number_of_avg_nodes = 10
# define search utility
nodal_neighbour_search = KratosPfem.NodalNeighboursSearch(self.model_part, self.echo_level, number_of_avg_elems, number_of_avg_nodes)
# execute search:
nodal_neighbour_search.Execute()
print("::[Modeler_Utility]:: Nodal Search executed ")
def ComputeBoundaryNormals(self, model_part, echo_level):
# define calculation utility
normals_calculation = KratosPfem.BoundaryNormalsCalculation()
# execute calculation:
#(scaled normals)
normals_calculation.CalculateWeightedBoundaryNormals(
model_part, echo_level)
#(unit normals)
# normals_calculation.CalculateUnitBoundaryNormals(model_part, self.echo_level)
if (echo_level > 0):
print("::[Domain_Utilities]:: Boundary Normals computed ")
def ExecuteInitialize(self):
# set model part
self.model_part = self.model[
self.settings["model_part_name"].GetString()]
params = KratosMultiphysics.Parameters("{}")
params.AddValue("variable_name", self.settings["variable_name"])
params.AddValue("flags_list", self.settings["flags_list"])
params.AddValue("properties", self.settings["properties"])
self.VolumeShapingProcess = KratosPfem.VolumeShapingProcess(
self.model_part, params)
self.VolumeShapingProcess.ExecuteInitialize()
def SearchElementNeighbours(self, model_part, echo_level):
dimension = model_part.ProcessInfo[KratosMultiphysics.SPACE_DIMENSION]
# set search options:
number_of_avg_elems = 10
# define search utility
elemental_neighbour_search = KratosPfem.ElementalNeighboursSearch(
model_part, dimension, echo_level, number_of_avg_elems)
# execute search:
elemental_neighbour_search.Execute()
if (echo_level > 0):
print("::[Domain_Utilities]:: Elemental Search executed ")
def BuildMeshBoundary(self):
print("::[Modeler_Utility]:: Build Mesh Boundary ")
# set building options:
mesh_id = 0
# define building utility
# skin_build = BuildMeshBoundary(self.model_part, self.domain_size, self.echo_level, mesh_id)
skin_build = KratosPfem.BuildMeshBoundary(self.model_part, mesh_id,
self.echo_level)
# execute building:
skin_build.Execute()
print("::[Modeler_Utility]:: Mesh Boundary Build executed ")
def ComputeAverageMeshParameters(self):
ModelerUtils = KratosPfem.ModelerUtilities()
self.domain_volume = ModelerUtils.ComputeModelPartVolume(
self.main_model_part)
self.element_mean_volume = 0
number_of_elements = self.main_model_part.NumberOfElements()
nodes_for_element = self.main_model_part.ProcessInfo[
KratosMultiphysics.DOMAIN_SIZE] + 1
if (number_of_elements != 0):
self.element_mean_volume = self.domain_volume / float(
number_of_elements * nodes_for_element)
self.RefiningParameters.SetMeanVolume(self.element_mean_volume)
