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)