def Initialize(self): """This function initializes the PfemFluidExplicitSolver Usage: It is designed to be called ONCE, BEFORE the execution of the solution-loop """ self.KratosPrintInfo("::[Pfem Fluid Explicit Solver]:: -START-") # Get the computing model part self.computing_model_part = self.GetComputingModelPart() mechanical_scheme = KratosPfemFluid.FirstOrderForwardEulerScheme( 1.0e-4, 1.0, 0, 0) import KratosMultiphysics.python_linear_solver_factory as linear_solver_factory linear_solver = linear_solver_factory.ConstructSolver( self.settings["velocity_linear_solver_settings"]) self.fluid_solver = KratosPfemFluid.ExplicitStrategy( self.computing_model_part, mechanical_scheme, linear_solver, False, True, True) # Set echo_level self.fluid_solver.SetEchoLevel(self.settings["echo_level"].GetInt()) # Set initialize flag if self.main_model_part.ProcessInfo[ KratosMultiphysics.IS_RESTARTED] == True: self.mechanical_solver.SetInitializePerformedFlag(True) # Check if everything is assigned correctly self.fluid_solver.Check() self.KratosPrintInfo("::[Pfem Fluid Explicit Solver]:: -END- ")
def _InitializeGiDIO(self, gidpost_flags, param): '''Initialize GidIO objects (for volume and cut outputs) and related data.''' self.volume_file_name = self.base_file_name self.cut_file_name = self.volume_file_name + "_cuts" self.post_mode = self.__get_gidpost_flag(param, "GiDPostMode", self.__post_mode) self.write_deformed_mesh = self.__get_gidpost_flag( param, "WriteDeformedMeshFlag", self.__write_deformed_mesh) self.write_conditions = self.__get_gidpost_flag( param, "WriteConditionsFlag", self.__write_conditions) self.multifile_flag = self.__get_gidpost_flag(param, "MultiFileFlag", self.__multi_file_flag) if self.body_output or self.node_output: self.body_io = PfemFluid.PfemFluidGidIO(self.volume_file_name, self.post_mode, self.multifile_flag, self.write_deformed_mesh, self.write_conditions) if self.skin_output or self.num_planes > 0: self.cut_io = PfemFluid.PfemFluidGidIO( self.cut_file_name, self.post_mode, self.multifile_flag, self.write_deformed_mesh, WriteConditionsFlag.WriteConditionsOnly ) # Cuts are conditions, so we always print conditions in the cut ModelPart
def SetPreMeshingProcesses(self): if (self.echo_level > 0): print( "::[fluid_pre_refining_mesher]:: -START SetPreMeshingProcesses-" ) refining_parameters = self.MeshingParameters.GetRefiningParameters() refining_options = refining_parameters.GetRefiningOptions() #recover_volume_losses = KratosPfemFluid.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 = KratosPfemFluid.SetActiveFlagMesherProcess( self.main_model_part, unactive_peak_elements, unactive_sliver_elements, self.echo_level) self.mesher.SetPreMeshingProcess(set_active_flag) inlet_management = KratosPfemFluid.InletManagement( self.model_part, self.MeshingParameters, self.echo_level) self.mesher.SetPreMeshingProcess(inlet_management) remove_mesh_nodes = KratosPfemFluid.RemoveMeshNodesForFluids( 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 = KratosPfemFluid.GenerateNewNodesBeforeMeshing( self.model_part, self.MeshingParameters, self.echo_level) self.mesher.SetPreMeshingProcess(generate_new_nodes)
def CreateAssignmentProcess(self, params): if( self.value_is_numeric ): params.AddValue("variable_name", self.settings["variable_name"]) counter = 0 for i in self.value: params["value"][counter].SetDouble(i) counter+=1 self.AssignValueProcess = PfemFluid.AssignVectorToConditionsProcess(self.model_part, params) else: #function values are assigned to a vector variable :: transformation is needed if( isinstance(self.var,KratosMultiphysics.Array1DVariable3) ): variable_name = self.settings["variable_name"].GetString() + "_VECTOR" #print("::[--Assign_Variable--]:: "+variable_name) params.AddEmptyValue("variable_name") params["variable_name"].SetString(variable_name) else: params.AddValue("variable_name", self.settings["variable_name"]) counter = 0 for i in self.value: params["value"][counter].SetDouble(i) counter+=1 params.AddEmptyValue("entity_type").SetString("CONDITIONS") self.AssignValueProcess = PfemFluid.AssignVectorFieldToEntitiesProcess(self.model_part, self.compiled_function, "function", self.value_is_spatial_function, params) # in case of going to previous time step for time step reduction self.CreateUnAssignmentProcess(params)
def SetPostMeshingProcesses(self): # The order set is the order of execution: if(self.echo_level>0): print("::[fluid_mesher]:: -START SetPostMeshingProcesses-") #select mesh elements select_mesh_elements = KratosPfemFluid.SelectMeshElementsForFluids(self.model_part, self.MeshingParameters, self.echo_level) self.mesher.SetPostMeshingProcess(select_mesh_elements) #rebuild elements #rebuild_mesh_elements = KratosDelaunay.BuildMeshElements(self.main_model_part, self.MeshingParameters, self.echo_level) #self.mesher.SetPostMeshingProcess(rebuild_mesh_elements) #rebuild elements rebuild_mesh_elements = KratosDelaunay.GenerateNewElements(self.model_part, self.MeshingParameters, self.echo_level) self.mesher.SetPostMeshingProcess(rebuild_mesh_elements) ### rebuild boundary ############ choose just one of the following two options: ############ ## use this if you want conditions ## ATTENTION: this is slow, and must be used together with ModelMeshingWithConditionsForFluids and BuildModelPartBoundary #rebuild_mesh_boundary = KratosPfemFluid.GenerateNewConditionsForFluids(self.model_part, self.MeshingParameters, self.echo_level) ## if you use the following, you will not use/build/compute conditions ## ATTENTION: it must be used together with ModelMeshingForFluids and BuildModelPartBoundaryForFluids rebuild_mesh_boundary = KratosPfemFluid.BuildMeshBoundaryForFluids(self.model_part, self.MeshingParameters, self.echo_level) ####################################################################### self.mesher.SetPostMeshingProcess(rebuild_mesh_boundary)
def SolveSolutionStep(self): pfem_is_converged = self.fluid_solver.SolveSolutionStep() KratosPfemFluid.SetMeshVelocityForThermalCouplingProcess(self.fluid_solver.main_model_part).Execute() KratosPfemFluid.SetMaterialPropertiesForThermalCouplingProcess(self.fluid_solver.main_model_part,self.thermal_solver.main_model_part).Execute() KM.Logger.Print("\nSolution of convection-diffusion at t=" + "{:.3f}".format(self.fluid_solver.main_model_part.ProcessInfo[KM.TIME]) + "s", label="") KM.Logger.Flush() thermal_is_converged = self.thermal_solver.SolveSolutionStep() return (pfem_is_converged and thermal_is_converged)
def CreateUnAssignmentProcess(self, params): params["compound_assignment"].SetString(self.GetInverseAssigment(self.settings["compound_assignment"].GetString())) if( self.value_is_numeric ): self.UnAssignValueProcess = PfemFluid.AssignScalarToEntitiesProcess(self.model_part, params) else: if( self.value_is_current_value ): self.UnAssignValueProcess = KratosMultiphysics.Process() #void process else: self.UnAssignValueProcess = PfemFluid.AssignScalarFieldToEntitiesProcess(self.model_part, self.compiled_function, "function", self.value_is_spatial_function, params)
def InitializeSolutionStep(self): #self.fluid_solver.InitializeSolutionStep() adaptive_time_interval = KratosPfemFluid.AdaptiveTimeIntervalProcess(self.main_model_part,self.settings["echo_level"].GetInt()) adaptive_time_interval.Execute() unactive_peak_elements = True unactive_sliver_elements = True set_active_flag = KratosPfemFluid.SetActiveFlagProcess(self.main_model_part,unactive_peak_elements,unactive_sliver_elements,self.settings["echo_level"].GetInt()) set_active_flag.Execute()
def CreateUnAssignmentProcess(self, params): params["compound_assignment"].SetString( self.GetInverseAssigment( self.settings["compound_assignment"].GetString())) if (self.value_is_numeric): self.UnAssignValueProcess = PfemFluid.AssignVectorToConditionsProcess( self.model_part, params) else: self.UnAssignValueProcess = PfemFluid.AssignVectorFieldToEntitiesProcess( self.model_part, self.compiled_function, "function", self.value_is_spatial_function, params)
def SetFixAndFreeProcesses(self,params): if( self.fix_time_integration == True ): params["variable_name"].SetString(self.settings["variable_name"].GetString()) self.primary_variable_name = self.TimeIntegrationMethod.GetPrimaryVariableName() if( self.primary_variable_name != self.variable_name ): params["variable_name"].SetString(self.primary_variable_name) fix_dof_process = PfemFluid.FixScalarPfemDofProcess(self.model_part, params) self.FixDofsProcesses.append(fix_dof_process) free_dof_process = PfemFluid.FreeScalarPfemDofProcess(self.model_part, params) self.FreeDofsProcesses.append(free_dof_process)
def SetPostMeshingProcesses(self): # The order set is the order of execution: print( "::[fluid_post_refining_modeler]:: -START SetPostMeshingProcesses-" ) #select mesh elements #generate_particles = KratosPfemBase.GenerateNewNodes(self.main_model_part, self.MeshingParameters, self.mesh_id, self.echo_level) #self.mesher.SetPostMeshingProcess(generate_particles) #select mesh elements #select_mesh_elements = KratosPfemBase.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 = KratosPfemBase.BuildMeshElements(self.main_model_part, self.MeshingParameters, self.mesh_id, self.echo_level) rebuild_mesh_elements = KratosPfemBase.BuildMeshElements( self.main_model_part, self.MeshingParameters, self.echo_level) self.mesher.SetPostMeshingProcess(rebuild_mesh_elements) #rebuild boundary rebuild_mesh_boundary = KratosPfemBase.ReconstructMeshBoundary( self.main_model_part, self.MeshingParameters, self.echo_level) self.mesher.SetPostMeshingProcess(rebuild_mesh_boundary)
def Initialize(self): KratosMultiphysics.Logger.PrintInfo( "SwimmingDEM", self.main_model_part.SetBufferSize( self.settings["buffer_size"].GetInt())) # Get the computing model part self.computing_model_part = self.GetComputingModelPart() self.fluid_solver = KratosPfemFluid.TwoStepVPDEMcouplingStrategy( self.computing_model_part, self.velocity_linear_solver, self.pressure_linear_solver, self.settings["reform_dofs_at_each_step"].GetBool(), self.settings["velocity_tolerance"].GetDouble(), self.settings["pressure_tolerance"].GetDouble(), self.settings["maximum_pressure_iterations"].GetInt(), self.settings["time_order"].GetInt(), self.main_model_part.ProcessInfo[ KratosMultiphysics.SPACE_DIMENSION]) echo_level = self.settings["echo_level"].GetInt() # Set echo_level self.fluid_solver.SetEchoLevel(echo_level) # Check if everything is assigned correctly self.fluid_solver.Check()
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 = KratosPfemBase.ModelerUtilities() meshing_options.Set(self.modeler_utils.KEEP_ISOLATED_NODES, True) #self.model_meshing = KratosPfemBase.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 __init__(self, Model, custom_settings ): assign_vector_components_to_nodes_process.AssignVectorComponentsToNodesProcess.__init__(self, Model, custom_settings) ##add inlet to fluid domain: #transfer_flags = KratosSolid.FlagsContainer() #transfer_flags.PushBack(KratosMultiphysics.NOT_FLUID) #assign_flags = KratosSolid.FlagsContainer() #assign_flags.PushBack(KratosMultiphysics.FLUID) #entity_type = "Nodes" #for part in self.model: #print(" A: Part ",part) #for sub_part in self.model[part].SubModelParts: #print(" B: SubPart ",sub_part) #if(sub_part.Is(KratosMultiphysics.FLUID)): #if(sub_part.IsNot(KratosMultiphysics.ACTIVE)): #print(" C: FLUID ",sub_part) #transfer_process = KratosSolid.TransferEntitiesProcess(sub_part,self.model_part,entity_type,transfer_flags,assign_flags) #transfer_process.Execute() self.model_part = Model[custom_settings["model_part_name"].GetString()] self.echo_level=0 self.model_inlet = KratosPfemFluid.SetInlet(self.model_part,self.echo_level) self.model_inlet.Execute()
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 Initialize(self): print("::[Pfem Fluid Solver]:: -START-") print(self.main_model_part.SetBufferSize(self.settings["buffer_size"].GetInt())) # Get the computing model part self.computing_model_part = self.GetComputingModelPart() self.fluid_solver = KratosPfemFluid.TwoStepVPDEMcouplingStrategy(self.computing_model_part, self.velocity_linear_solver, self.pressure_linear_solver, self.settings["reform_dofs_at_each_step"].GetBool(), self.settings["velocity_tolerance"].GetDouble(), self.settings["pressure_tolerance"].GetDouble(), self.settings["maximum_pressure_iterations"].GetInt(), self.settings["time_order"].GetInt(), self.main_model_part.ProcessInfo[KratosMultiphysics.SPACE_DIMENSION]) echo_level = self.settings["echo_level"].GetInt() # Set echo_level self.fluid_solver.SetEchoLevel(echo_level) # Set initialize flag if( self.main_model_part.ProcessInfo[KratosMultiphysics.IS_RESTARTED] == True ): self.mechanical_solver.SetInitializePerformedFlag(True) # Check if everything is assigned correctly self.fluid_solver.Check() print("::[Pfem Fluid Solver]:: -END- ")
def RemeshDomains(self): if(self.remesh_domains): if( self.echo_level >= 0 ): print("::[Modeler_Utility]:: MESH DOMAIN...", self.counter) #meshing_options = Flags() meshing_options = KratosMultiphysics.Flags() #self.model_meshing = ModelMeshing(self.model_part, meshing_options, self.echo_level) self.model_meshing = KratosPfemFluid.ModelMeshingForFluids(self.model_part, meshing_options, self.echo_level) ##self.model_meshing = ModelMeshingForFluids(self.model_part, meshing_options, self.echo_level) self.model_meshing.ExecuteInitialize() id = 0 for mesher in self.mesh_modelers: mesh_id = self.mesh_ids[id] mesher.InitializeMeshModeler(self.model_part) mesher.GenerateMesh(self.model_part); mesher.FinalizeMeshModeler(self.model_part) self.remesh_executed = True id+=1 self.model_meshing.ExecuteFinalize() self.counter += 1
def ExecuteInitializeSolutionStep(self): """This function executes the Initialize solution step of the process """ self.step_count += 1 currentTime = self.main_model_part.ProcessInfo[KratosMultiphysics.TIME] currentStep = self.main_model_part.ProcessInfo[KratosMultiphysics.STEP] if currentStep >= 2 and self.fileTotalVolume is None and self.write_total_volume: self.fileTotalVolume = open("totalVolumeBeforeMeshing.txt", 'w') if (currentStep > 1 and self.fileTotalVolume is not None): for domain in self.meshing_domains: if (domain.Active()): domain.ComputeAverageMeshParameters() meanVolumeBeforeMeshing = domain.GetMeanVolume() totalVolumeBeforeMeshing = domain.GetTotalVolume() outstring = str(currentTime) + " " + str( totalVolumeBeforeMeshing) + " " self.fileTotalVolume.write(outstring) volume_acceleration = self.main_model_part.ProcessInfo[ KratosMultiphysics.GRAVITY] variable_utils = KratosMultiphysics.VariableUtils() if (currentStep == 1): variable_utils.SetVectorVar(KratosMultiphysics.VOLUME_ACCELERATION, volume_acceleration, self.main_model_part.Nodes) if self.remesh_domains_active: if self.meshing_before_output: if self.IsMeshingStep(): if self.echo_level > 1: print( "::[Remesh_Fluid_Domains_Process]:: RemeshFluidDomains " ) self.RemeshFluidDomains() # Updating conditions on the free surface if self.update_conditions_on_free_surface: if self.echo_level > 1: print( "::[Remesh_Fluid_Domains_Process]:: UpdateConditionsOnFreeSurface " ) KratosPfemFluid.UpdateConditionsOnFreeSurfaceProcess(self.main_model_part, \ self.settings["update_conditions_on_free_surface"]).Execute() if currentStep > 1 and self.fileTotalVolume is not None: for domain in self.meshing_domains: if domain.Active(): domain.ComputeAverageMeshParameters() meanVolumeAfterMeshing = domain.GetMeanVolume() totalVolumeAfterMeshing = domain.GetTotalVolume() diffMeanVolume = meanVolumeAfterMeshing - meanVolumeBeforeMeshing diffTotalVolume = totalVolumeAfterMeshing - totalVolumeBeforeMeshing outstring = str(totalVolumeAfterMeshing) + " " + str( diffTotalVolume) + "\n" self.fileTotalVolume.write(outstring) if self.fileTotalVolume is not None: self.fileTotalVolume.flush()
def InitializeSolutionStep(self): #self.fluid_solver.InitializeSolutionStep() if self._TimeBufferIsInitialized(): self.fluid_solver.InitializeSolutionStep() if (self.settings["time_stepping"]["automatic_time_step"].GetBool()): adaptive_time_interval = KratosPfemFluid.AdaptiveTimeIntervalProcess(self.main_model_part,self.settings["echo_level"].GetInt()) adaptive_time_interval.Execute()
def SetPostMeshingProcesses(self): # The order set is the order of execution: if(self.echo_level>0): print("::[fluid_mesher]:: -START SetPostMeshingProcesses-") rebuild_mesh_boundary = KratosPfemFluid.BuildMeshBoundaryForFluids(self.model_part, self.MeshingParameters, self.echo_level) self.mesher.SetPostMeshingProcess(rebuild_mesh_boundary)
def CreateAssignmentProcess(self, params): params["variable_name"].SetString(self.settings["variable_name"].GetString()) if( self.value_is_numeric ): params.AddEmptyValue("value").SetDouble(self.value) params.AddEmptyValue("entity_type").SetString("NODES") self.AssignValueProcess = PfemFluid.AssignScalarToEntitiesProcess(self.model_part, params) else: if( self.value_is_current_value ): self.AssignValueProcess = KratosMultiphysics.Process() #void process else: params.AddEmptyValue("entity_type").SetString("NODES") self.AssignValueProcess = PfemFluid.AssignScalarFieldToEntitiesProcess(self.model_part, self.compiled_function, "function", self.value_is_spatial_function, params) # in case of going to previous time step for time step reduction self.CreateUnAssignmentProcess(params)
def FinalizeSolutionStep(self): #pass self.fluid_solver.FinalizeSolutionStep() unactive_peak_elements = True unactive_sliver_elements = True set_active_flag = KratosPfemFluid.SetActiveFlagProcess(self.main_model_part,unactive_peak_elements,unactive_sliver_elements,self.settings["echo_level"].GetInt()) set_active_flag.ExecuteFinalize()
def InitializeSolutionStep(self): KratosPfemFluid.UpdateThermalModelPartProcess( self.fluid_solver.main_model_part, \ self.thermal_solver.main_model_part, \ self.thermal_solver.GetComputingModelPart(), \ self.domain_size).Execute() self.fluid_solver.InitializeSolutionStep() self.thermal_solver.InitializeSolutionStep()
def SetPreMeshingProcesses(self): if(self.echo_level>0): print("::[fluid_mesher]:: -START SetPreMeshingProcesses-") unactive_peak_elements = False unactive_sliver_elements = False set_active_flag = KratosPfemFluid.SetActiveFlagMesherProcess(self.main_model_part,unactive_peak_elements,unactive_sliver_elements,self.echo_level) self.mesher.SetPreMeshingProcess(set_active_flag)
def Initialize(self): print("::[Pfem Fluid Explicit Solver]:: -START-") # Get the computing model part self.computing_model_part = self.GetComputingModelPart() #mechanical_scheme = KratosSolidMechanics.ExplicitCentralDifferencesScheme(self.settings["max_delta_time"].GetDouble(), # self.settings["fraction_delta_time"].GetDouble(), # self.settings["time_step_prediction_level"].GetDouble(), # self.settings["rayleigh_damping"].GetBool()) mechanical_scheme = KratosPfemFluid.FirstOrderForwardEulerScheme(1.0e-4, 1.0, 0, 0) import KratosMultiphysics.python_linear_solver_factory as linear_solver_factory linear_solver = linear_solver_factory.ConstructSolver(self.settings["velocity_linear_solver_settings"]) #self.fluid_solver = KratosPfemFluid.ExplicitStrategy(self.computing_model_part, # mechanical_scheme, # linear_solver, # self.settings["compute_reactions"].GetBool(), # self.settings["reform_dofs_at_each_step"].GetBool(), # self.settings["move_mesh_flag"].GetBool()) self.fluid_solver = KratosPfemFluid.ExplicitStrategy(self.computing_model_part, mechanical_scheme, linear_solver, False, True, True) # Set echo_level self.fluid_solver.SetEchoLevel(self.settings["echo_level"].GetInt()) # Set initialize flag if( self.main_model_part.ProcessInfo[KratosMultiphysics.IS_RESTARTED] == True ): self.mechanical_solver.SetInitializePerformedFlag(True) # Check if everything is assigned correctly self.fluid_solver.Check() print("::[Pfem Fluid Explicit Solver]:: -END- ")
def SetPostMeshingProcesses(self): # The order set is the order of execution: if (self.echo_level > 0): print("::[fluid_mesher]:: -START SetPostMeshingProcesses-") #select mesh elements select_mesh_elements = KratosPfemFluid.SelectMeshElementsForFluids( self.model_part, self.MeshingParameters, self.echo_level) self.mesher.SetPostMeshingProcess(select_mesh_elements) #rebuild elements rebuild_mesh_elements = KratosDelaunay.GenerateNewElements( self.model_part, self.MeshingParameters, self.echo_level) self.mesher.SetPostMeshingProcess(rebuild_mesh_elements) rebuild_mesh_boundary = KratosPfemFluid.BuildMeshBoundaryForFluids( self.model_part, self.MeshingParameters, self.echo_level) self.mesher.SetPostMeshingProcess(rebuild_mesh_boundary)
def __init__(self, Model, custom_settings): AssignVectorComponentsToNodesProcess.__init__(self, Model, custom_settings) self.model_part = Model[custom_settings["model_part_name"].GetString()] self.echo_level = 0 self.model_inlet = KratosPfemFluid.SetInlet(self.model_part, self.echo_level) self.model_inlet.Execute()
def SetPreMeshingProcesses(self): if(self.echo_level>0): print("::[fluid_mesher]:: -START SetPreMeshingProcesses-") #recover_volume_losses = KratosPfemFluid.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 = KratosPfemFluid.SetActiveFlagMesherProcess(self.main_model_part,unactive_peak_elements,unactive_sliver_elements,self.echo_level) self.mesher.SetPreMeshingProcess(set_active_flag) inlet_management = KratosPfemFluid.InletManagement(self.model_part, self.MeshingParameters, self.echo_level) self.mesher.SetPreMeshingProcess(inlet_management) remove_mesh_nodes = KratosPfemFluid.RemoveMeshNodesForFluids(self.model_part, self.MeshingParameters, self.echo_level) self.mesher.SetPreMeshingProcess(remove_mesh_nodes) generate_new_nodes = KratosPfemFluid.GenerateNewNodesBeforeMeshing(self.model_part, self.MeshingParameters, self.echo_level) self.mesher.SetPreMeshingProcess(generate_new_nodes)
def BuildMeshBoundaryForFluids(self): print("::[Modeler_Utility]:: Build Mesh Boundary for fluids ") # set building options: mesh_id = 0 # define building utility skin_build = KratosPfemFluid.BuildMeshBoundaryForFluids(self.model_part, self.echo_level, mesh_id) # execute building: skin_build.Execute() print("::[Modeler_Utility]:: Mesh Boundary Build executed ")
def SetPreMeshingProcesses(self): if (self.echo_level > 0): print("::[fluid_mesher]:: -START SetPreMeshingProcesses-") #recover_volume_losses = KratosPfemFluid.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 = KratosPfemFluid.SetActiveFlagMesherProcess( self.main_model_part, unactive_peak_elements, unactive_sliver_elements, self.echo_level) self.mesher.SetPreMeshingProcess(set_active_flag)