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.mesher_utils = KratosDelaunay.MesherUtilities()
meshing_options.Set(self.mesher_utils.KEEP_ISOLATED_NODES, True)
#self.model_meshing = KratosDelaunay.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 Check(self):
# set mesher utilities
self.mesher_utils = KratosDelaunay.MesherUtilities()
critical_radius = self.mesher_utils.CheckCriticalRadius(self.main_model_part,critical_mesh_size)
print(" CriticalRadius ", critical_radius)
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 Check(self):
# set mesher utilities
self.mesher_utils = KratosDelaunay.MesherUtilities()
# set the domain labels to mesh mesher
critical_mesh_size = self.settings["refining_parameters"][
"critical_size"].GetDouble()
critical_radius = self.mesher_utils.CheckCriticalRadius(
self.main_model_part, critical_mesh_size)
print(" CriticalRadius ", critical_radius)
def ComputeAverageMeshParameters(self):
MesherUtils = KratosDelaunay.MesherUtilities();
self.domain_volume = MesherUtils.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.SPACE_DIMENSION] + 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)
def SetMeshSizeValues(self):
critical_mesh_size = self.settings["refining_parameters"][
"critical_size"].GetDouble()
critical_mesh_side = 0
if (critical_mesh_size != 0.0):
# set mesh refinement based on wall tip discretization size
# if(parameters["TipRadiusRefine"]):
# tip arch opening (in degrees = 5-7.5-10)
#tool_arch_opening = 12
# tip surface length
#tool_arch_length = tool_arch_opening * (3.1416 / 180.0)
# critical mesh size based on wall tip
#critical_mesh_size = tool_arch_length * parameters["CriticalTipRadius"]
critical_mesh_side = critical_mesh_size * 3
else:
number_of_nodes = 0
mean_nodal_size = 0
for node in self.main_model_part.Nodes:
if (node.IsNot(KratosMultiphysics.RIGID)):
number_of_nodes += 1
mean_nodal_size = mean_nodal_size + node.GetSolutionStepValue(
KratosMultiphysics.NODAL_H)
critical_mesh_size = 0.25 * mean_nodal_size / number_of_nodes
critical_mesh_side = critical_mesh_size * 3
#self.RefiningParameters.SetInitialRadius(critical_mesh_size)
self.RefiningParameters.SetCriticalRadius(critical_mesh_size)
self.RefiningParameters.SetCriticalSide(critical_mesh_side)
#set mean area or mean volume
MesherUtils = KratosDelaunay.MesherUtilities()
domain_volume = MesherUtils.ComputeModelPartVolume(
self.main_model_part)
number_of_elements = self.main_model_part.NumberOfElements()
dimension = self.main_model_part.ProcessInfo[
KratosMultiphysics.SPACE_DIMENSION]
factor = float(number_of_elements * (dimension + 1))
mean_volume = (4.0 * critical_mesh_size)**dimension
if (factor != 0):
mean_volume = domain_volume / factor
self.RefiningParameters.SetMeanVolume(mean_volume)
def InitializeDomains(self):
# initialize the mesher
if (self.echo_level > 1):
print("::[Remesh_Fluid_Domains]:: Initialize Domains ")
import domain_utilities
domain_utils = domain_utilities.DomainUtilities()
# find node neighbours
domain_utils.SearchNodeNeighbours(self.main_model_part,
self.echo_level)
# find element neighbours
domain_utils.SearchElementNeighbours(self.main_model_part,
self.echo_level)
# set neighbour search performed
self.neighbour_search_performed = True
# set mesher utilities
self.mesher_utils = KratosDelaunay.MesherUtilities()
# set the domain labels to conditions
self.mesher_utils.SetModelPartNameToConditions(self.main_model_part)
# find skin and boundary normals
if (self.restart == False):
self.BuildMeshBoundaryForFluids()
#domain_utils.ConstructModelPartBoundary(self.main_model_part, self.echo_level)
# search nodal h
if (self.neighbour_search_performed):
domain_utils.SearchNodalH(self.main_model_part,
self.echo_level)
# set the domain labels to nodes
self.mesher_utils.SetModelPartNameToNodes(self.main_model_part)
self.main_model_part.ProcessInfo.SetValue(
KratosDelaunay.INITIALIZED_DOMAINS, True)
if (self.echo_level > 1):
print(self.main_model_part)
def InitializeDomains(self, model_part, echo_level):
if (model_part.ProcessInfo[KratosDelaunay.INITIALIZED_DOMAINS] == False
):
# initialize the mesher
print("::[--Domain Utilities-]:: Initialize", model_part.Name)
# find node neighbours
self.SearchNodeNeighbours(model_part, echo_level)
# find element neighbours
self.SearchElementNeighbours(model_part, echo_level)
# set mesher utilities
mesher_utils = KratosDelaunay.MesherUtilities()
# set the domain labels to conditions
mesher_utils.SetModelPartNameToConditions(model_part)
# set the domain labels to elements
mesher_utils.SetModelPartNameToElements(model_part)
# find skin and boundary normals
if (model_part.ProcessInfo[KratosMultiphysics.IS_RESTARTED] ==
False):
# build boundary of a volumetric body domain
self.BuildModelPartBoundary(model_part, echo_level)
# search nodal h
self.SearchNodalH(model_part, echo_level)
# add rigid and solid boundary nodes to fluid domains:
self.AddBoundaryNodesToFluidDomains(model_part)
# set the domain labels to nodes
mesher_utils.SetModelPartNameToNodes(model_part)
model_part.ProcessInfo.SetValue(KratosDelaunay.INITIALIZED_DOMAINS,
True)
if (echo_level > 0):
print("::[--Domain Utilities-]:: Resultant ModelPart")
print(model_part)
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.mesher_utils = KratosDelaunay.MesherUtilities()
meshing_options.Set(self.mesher_utils.KEEP_ISOLATED_NODES, True)
############ choose just one of the following two options: ############
## use this if you want conditions
## ATTENTION: this is slow, and must be used together with GenerateNewConditionsForFluids and BuildModelPartBoundary
#self.model_meshing = KratosPfemFluid.ModelMeshingWithConditionsForFluids(self.main_model_part, meshing_options, self.echo_level)
## if you use the following, you will not use/build/compute conditions
## ATTENTION: it must be used together with BuildMeshBoundaryForFluids and BuildModelPartBoundaryForFluids
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 InitializeDomains(self):
"""This function Initializes the Domains
"""
# initialize the mesher
if self.echo_level > 1:
print("::[Remesh_Fluid_Domains]:: Initialize Domains ")
from KratosMultiphysics.DelaunayMeshingApplication import domain_utilities
domain_utils = domain_utilities.DomainUtilities()
# find node neighbours
domain_utils.SearchNodeNeighbours(self.main_model_part,
self.echo_level)
# find element neighbours
domain_utils.SearchElementNeighbours(self.main_model_part,
self.echo_level)
# set neighbour search performed
self.neighbour_search_performed = True
# set mesher utilities
self.mesher_utils = KratosDelaunay.MesherUtilities()
# set the domain labels to conditions
self.mesher_utils.SetModelPartNameToConditions(self.main_model_part)
# find skin and boundary normals
self.BuildMeshBoundaryForFluids()
# search nodal h
if self.neighbour_search_performed:
domain_utils.SearchNodalH(self.main_model_part, self.echo_level)
# set the domain labels to nodes
self.mesher_utils.SetModelPartNameToNodes(self.main_model_part)
self.main_model_part.ProcessInfo.SetValue(
KratosDelaunay.INITIALIZED_DOMAINS, True)
if self.echo_level > 1:
print(self.main_model_part)