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 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 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)
def InitializeDomains(self):
# initialize the modeler
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 modeler utilities
self.modeler_utils = KratosPfem.ModelerUtilities()
# set the domain labels to conditions
self.modeler_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.modeler_utils.SetModelPartNameToNodes(self.main_model_part)
self.main_model_part.ProcessInfo.SetValue(
KratosPfem.INITIALIZED_DOMAINS, True)
if (self.echo_level > 1):
print(self.main_model_part)
def InitializeDomains(self, model_part, echo_level):
if (model_part.ProcessInfo[KratosPfem.INITIALIZED_DOMAINS] == False):
# initialize the modeler
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 modeler utilities
modeler_utils = KratosPfem.ModelerUtilities()
# set the domain labels to conditions
modeler_utils.SetModelPartNameToConditions(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)
# set the domain labels to nodes
modeler_utils.SetModelPartNameToNodes(model_part)
model_part.ProcessInfo.SetValue(KratosPfem.INITIALIZED_DOMAINS,
True)
print("::[Domain_Utilities]:: Resultant ModelPart")
print(model_part)
