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)