def _ExecuteAfterReading(self): ## Replace element and conditions KratosMultiphysics.ReplaceElementsAndConditionsProcess( self.main_model_part, self.settings["element_replace_settings"]).Execute() ## Check that the input read has the shape we like prepare_model_part_settings = KratosMultiphysics.Parameters("{}") prepare_model_part_settings.AddValue( "volume_model_part_name", self.settings["volume_model_part_name"]) prepare_model_part_settings.AddValue("skin_parts", self.settings["skin_parts"]) import check_and_prepare_model_process_fluid check_and_prepare_model_process_fluid.CheckAndPrepareModelProcess( self.main_model_part, prepare_model_part_settings).Execute() # Read the KINEMATIC VISCOSITY and DENSITY and we apply it to the nodes for el in self.main_model_part.Elements: rho = el.Properties.GetValue(KratosMultiphysics.DENSITY) # kin_viscosity = el.Properties.GetValue(KratosMultiphysics.VISCOSITY) break KratosMultiphysics.VariableUtils().SetScalarVar( KratosMultiphysics.DENSITY, rho, self.main_model_part.Nodes)
def _ExecuteCheckAndPrepare(self): ## Check that the input read has the shape we like prepare_model_part_settings = KratosMultiphysics.Parameters("{}") prepare_model_part_settings.AddValue("volume_model_part_name",self.settings["volume_model_part_name"]) prepare_model_part_settings.AddValue("skin_parts",self.settings["skin_parts"]) import check_and_prepare_model_process_fluid check_and_prepare_model_process_fluid.CheckAndPrepareModelProcess(self.main_model_part, prepare_model_part_settings).Execute()
def ImportModelPart(self): if (self.settings["model_import_settings"]["input_type"].GetString() == "mdpa"): #here it would be the place to import restart data if required kratoscore.ModelPartIO( self.settings["model_import_settings"] ["input_filename"].GetString()).ReadModelPart( self.main_model_part) self.settings.AddEmptyValue("element_replace_settings") if (self.main_model_part.ProcessInfo[ KratosMultiphysics.DOMAIN_SIZE] == 3): self.settings[ "element_replace_settings"] = KratosMultiphysics.Parameters( """ { "element_name":"StokesTwoFluid3D4N", "condition_name": "StokesWallCondition3D" } """) elif (self.main_model_part.ProcessInfo[ KratosMultiphysics.DOMAIN_SIZE] == 2): raise Exception("sorry 2D case not implemented") else: raise Exception("domain size is not 2 or 3") KratosMultiphysics.ReplaceElementsAndConditionsProcess( self.main_model_part, self.settings["element_replace_settings"]).Execute() ##here we shall check that the input read has the shape we like aux_params = kratoscore.Parameters("{}") aux_params.AddValue("volume_model_part_name", self.settings["volume_model_part_name"]) aux_params.AddValue("skin_parts", self.settings["skin_parts"]) import check_and_prepare_model_process_fluid check_and_prepare_model_process_fluid.CheckAndPrepareModelProcess( self.main_model_part, aux_params).Execute() ##here we must construct correctly the constitutive law print( "don't forget constructing the constitutive law!!!!!!!!!!!!!!") #if needed here we shall generate the constitutive laws #import constitutive_law_python_utility as constitutive_law_utils #constitutive_law = constitutive_law_utils.ConstitutiveLawUtility(main_model_part, self.settings["DomainSize"]); #constitutive_law.Initialize(); else: raise Exception("other input options are not yet implemented") current_buffer_size = self.main_model_part.GetBufferSize() if (self.GetMinimumBufferSize() > current_buffer_size): self.main_model_part.SetBufferSize(self.GetMinimumBufferSize()) print("model reading finished")
def ImportModelPart(self): if(self.settings["model_import_settings"]["input_type"].GetString() == "mdpa"): # here it would be the place to import restart data if required KratosMultiphysics.ModelPartIO(self.settings["model_import_settings"]["input_filename"].GetString()).ReadModelPart(self.main_model_part) # here we shall check that the input read has the shape we like aux_params = KratosMultiphysics.Parameters("{}") aux_params.AddValue("volume_model_part_name",self.settings["volume_model_part_name"]) aux_params.AddValue("skin_parts",self.settings["skin_parts"]) # here we replace the dummy elements we read with proper elements self.settings.AddEmptyValue("element_replace_settings") if(self.main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE] == 3): self.settings["element_replace_settings"] = KratosMultiphysics.Parameters(""" { "element_name": "VMSAdjointElement3D", "condition_name": "SurfaceCondition3D3N" } """) elif(self.main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE] == 2): self.settings["element_replace_settings"] = KratosMultiphysics.Parameters(""" { "element_name": "VMSAdjointElement2D", "condition_name": "LineCondition2D2N" } """) else: raise Exception("domain size is not 2 or 3") KratosMultiphysics.ReplaceElementsAndConditionsProcess(self.main_model_part, self.settings["element_replace_settings"]).Execute() import check_and_prepare_model_process_fluid check_and_prepare_model_process_fluid.CheckAndPrepareModelProcess(self.main_model_part, aux_params).Execute() #here we read the KINEMATIC VISCOSITY and DENSITY and we apply it to the nodes for el in self.main_model_part.Elements: rho = el.Properties.GetValue(KratosMultiphysics.DENSITY) if el.Properties.Has(KratosMultiphysics.DYNAMIC_VISCOSITY): dyn_viscosity = el.Properties.GetValue(KratosMultiphysics.DYNAMIC_VISCOSITY) kin_viscosity = dyn_viscosity/rho else: kin_viscosity = el.Properties.GetValue(KratosMultiphysics.VISCOSITY) break KratosMultiphysics.VariableUtils().SetScalarVar(KratosMultiphysics.DENSITY, rho, self.main_model_part.Nodes) KratosMultiphysics.VariableUtils().SetScalarVar(KratosMultiphysics.VISCOSITY, kin_viscosity, self.main_model_part.Nodes) else: raise Exception("Other input options are not yet implemented.") current_buffer_size = self.main_model_part.GetBufferSize() if(self.GetMinimumBufferSize() > current_buffer_size): self.main_model_part.SetBufferSize( self.GetMinimumBufferSize() ) print ("Model reading finished.")
def _ExecuteAfterReading(self): ## Replace element and conditions KratosMultiphysics.ReplaceElementsAndConditionsProcess(self.main_model_part, self.settings["element_replace_settings"]).Execute() ## Check that the input read has the shape we like prepare_model_part_settings = KratosMultiphysics.Parameters("{}") prepare_model_part_settings.AddValue("volume_model_part_name",self.settings["volume_model_part_name"]) prepare_model_part_settings.AddValue("skin_parts",self.settings["skin_parts"]) import check_and_prepare_model_process_fluid check_and_prepare_model_process_fluid.CheckAndPrepareModelProcess(self.main_model_part, prepare_model_part_settings).Execute()
def _ExecuteCheckAndPrepare(self): ## Check that the input read has the shape we like prepare_model_part_settings = KratosMultiphysics.Parameters("{}") prepare_model_part_settings.AddValue("volume_model_part_name",self.settings["volume_model_part_name"]) prepare_model_part_settings.AddValue("skin_parts",self.settings["skin_parts"]) import check_and_prepare_model_process_fluid check_and_prepare_model_process_fluid.CheckAndPrepareModelProcess(self.main_model_part, prepare_model_part_settings).Execute() current_buffer_size = self.main_model_part.GetBufferSize() if(self.GetMinimumBufferSize() > current_buffer_size): self.main_model_part.SetBufferSize( self.GetMinimumBufferSize() )
def __init__(self, ProjectParameters): # Json format solvers settings ProjectParametersFluid = ProjectParameters["fluid_solver_settings"] ProjectParametersSolid = ProjectParameters["structure_solver_settings"] # Defining a model part for the fluid and one for the structure self.structure_main_model_part = ModelPart("structure_part") self.fluid_main_model_part = ModelPart("fluid_part") # Set the domain size (2D or 3D test) self.structure_main_model_part.ProcessInfo.SetValue( DOMAIN_SIZE, ProjectParametersFluid["problem_data"]["domain_size"].GetInt()) self.fluid_main_model_part.ProcessInfo.SetValue( DOMAIN_SIZE, ProjectParametersSolid["problem_data"]["domain_size"].GetInt()) # Set the fluid and solid models FluidModel = { ProjectParametersFluid["problem_data"]["model_part_name"].GetString( ): self.structure_main_model_part } SolidModel = { ProjectParametersSolid["problem_data"]["model_part_name"].GetString( ): self.fluid_main_model_part } # Fluid model part variables addition self.fluid_main_model_part.AddNodalSolutionStepVariable(VELOCITY) self.fluid_main_model_part.AddNodalSolutionStepVariable(PRESSURE) self.fluid_main_model_part.AddNodalSolutionStepVariable(REACTION) # Structure model part variables addition self.structure_main_model_part.AddNodalSolutionStepVariable(VELOCITY) self.structure_main_model_part.AddNodalSolutionStepVariable(PRESSURE) self.structure_main_model_part.AddNodalSolutionStepVariable(POINT_LOAD) # Mapper variables addition NonConformant_OneSideMap.AddVariables(self.fluid_main_model_part, self.structure_main_model_part) # Fluid domain model reading ModelPartIO( ProjectParametersFluid["solver_settings"]["model_import_settings"] ["input_filename"].GetString()).ReadModelPart( self.fluid_main_model_part) prepare_model_part_settings_fluid = Parameters("{}") prepare_model_part_settings_fluid.AddValue( "volume_model_part_name", ProjectParametersFluid["solver_settings"] ["volume_model_part_name"]) prepare_model_part_settings_fluid.AddValue( "skin_parts", ProjectParametersFluid["solver_settings"]["skin_parts"]) import check_and_prepare_model_process_fluid check_and_prepare_model_process_fluid.CheckAndPrepareModelProcess( self.fluid_main_model_part, prepare_model_part_settings_fluid).Execute() # Solid domain model reading computing_model_part_name = "computing_domain" ModelPartIO( ProjectParametersSolid["solver_settings"]["model_import_settings"] ["input_filename"].GetString()).ReadModelPart( self.structure_main_model_part) prepare_model_part_settings_structure = Parameters("{}") prepare_model_part_settings_structure.AddEmptyValue( "computing_model_part_name").SetString(computing_model_part_name) prepare_model_part_settings_structure.AddValue( "problem_domain_sub_model_part_list", ProjectParametersSolid["solver_settings"] ["problem_domain_sub_model_part_list"]) prepare_model_part_settings_structure.AddValue( "processes_sub_model_part_list", ProjectParametersSolid["solver_settings"] ["processes_sub_model_part_list"]) import check_and_prepare_model_process_structural check_and_prepare_model_process_structural.CheckAndPrepareModelProcess( self.structure_main_model_part, prepare_model_part_settings_structure).Execute() # Get the list of the skin submodel parts where the fluid interface submodel part is stored for i in range(ProjectParametersFluid["solver_settings"] ["skin_parts"].size()): skin_part_name = ProjectParametersFluid["solver_settings"][ "skin_parts"][i].GetString() FluidModel.update({ skin_part_name: self.fluid_main_model_part.GetSubModelPart(skin_part_name) }) # Get the list of the submodel parts where the structure interface is stored for i in range(ProjectParametersSolid["solver_settings"] ["processes_sub_model_part_list"].size()): part_name = ProjectParametersSolid["solver_settings"][ "processes_sub_model_part_list"][i].GetString() SolidModel.update({ part_name: self.structure_main_model_part.GetSubModelPart(part_name) }) # Construct processes self.list_of_processes = process_factory.KratosProcessFactory( FluidModel).ConstructListOfProcesses( ProjectParametersFluid["boundary_conditions_process_list"]) self.list_of_processes += process_factory.KratosProcessFactory( SolidModel).ConstructListOfProcesses( ProjectParametersSolid["constraints_process_list"]) # Set fluid and structure interfaces for node in self.fluid_main_model_part.GetSubModelPart( "Fluid_interface").Nodes: node.Set(INTERFACE, True) for node in self.structure_main_model_part.GetSubModelPart( "Structure_interface").Nodes: node.Set(INTERFACE, True) for process in self.list_of_processes: process.ExecuteInitialize() # Mapper construction search_radius_factor = 2.0 mapper_max_iterations = 200 mapper_tolerance = 1e-12 self.mapper = NonConformant_OneSideMap.NonConformant_OneSideMap( self.fluid_main_model_part, self.structure_main_model_part, search_radius_factor, mapper_max_iterations, mapper_tolerance) # Output settings self.output_post = False # Set this variable to True if it is need to print the results for debugging purposes self.problem_path = os.getcwd() if (self.output_post == True): from gid_output_process import GiDOutputProcess self.gid_output_structure = GiDOutputProcess( self.structure_main_model_part, ProjectParametersSolid["problem_data"] ["problem_name"].GetString() + "_structure", ProjectParametersSolid["output_configuration"]) self.gid_output_fluid = GiDOutputProcess( self.fluid_main_model_part, ProjectParametersFluid["problem_data"] ["problem_name"].GetString() + "_fluid", ProjectParametersFluid["output_configuration"]) self.gid_output_structure.ExecuteInitialize() self.gid_output_fluid.ExecuteInitialize()
def ImportModelPart(self): if (self.settings["model_import_settings"]["input_type"].GetString() == "mdpa"): # here we read the already existing partitions from the primal solution. input_filename = self.settings["model_import_settings"][ "input_filename"].GetString() mpi_input_filename = input_filename + "_" + str(KratosMPI.mpi.rank) self.settings["model_import_settings"]["input_filename"].SetString( mpi_input_filename) KratosMultiphysics.ModelPartIO(mpi_input_filename).ReadModelPart( self.main_model_part) # here we shall check that the input read has the shape we like aux_params = KratosMultiphysics.Parameters("{}") aux_params.AddValue("volume_model_part_name", self.settings["volume_model_part_name"]) aux_params.AddValue("skin_parts", self.settings["skin_parts"]) # here we replace the dummy elements we read with proper elements self.settings.AddEmptyValue("element_replace_settings") if (self.main_model_part.ProcessInfo[ KratosMultiphysics.DOMAIN_SIZE] == 3): self.settings[ "element_replace_settings"] = KratosMultiphysics.Parameters( """ { "element_name": "VMSAdjointElement3D", "condition_name": "SurfaceCondition3D3N" } """) elif (self.main_model_part.ProcessInfo[ KratosMultiphysics.DOMAIN_SIZE] == 2): self.settings[ "element_replace_settings"] = KratosMultiphysics.Parameters( """ { "element_name": "VMSAdjointElement2D", "condition_name": "LineCondition2D2N" } """) else: raise Exception("domain size is not 2 nor 3") KratosMultiphysics.ReplaceElementsAndConditionsProcess( self.main_model_part, self.settings["element_replace_settings"]).Execute() import check_and_prepare_model_process_fluid check_and_prepare_model_process_fluid.CheckAndPrepareModelProcess( self.main_model_part, aux_params).Execute() # here we read the KINEMATIC VISCOSITY and DENSITY and we apply it to the nodes for el in self.main_model_part.Elements: rho = el.Properties.GetValue(KratosMultiphysics.DENSITY) kin_viscosity = el.Properties.GetValue( KratosMultiphysics.VISCOSITY) break KratosMultiphysics.VariableUtils().SetScalarVar( KratosMultiphysics.DENSITY, rho, self.main_model_part.Nodes) KratosMultiphysics.VariableUtils().SetScalarVar( KratosMultiphysics.VISCOSITY, kin_viscosity, self.main_model_part.Nodes) else: raise Exception("Other input options are not yet implemented.") current_buffer_size = self.main_model_part.GetBufferSize() if (self.GetMinimumBufferSize() > current_buffer_size): self.main_model_part.SetBufferSize(self.GetMinimumBufferSize()) MetisApplication.SetMPICommunicatorProcess( self.main_model_part).Execute() ParallelFillCommunicator = TrilinosApplication.ParallelFillCommunicator( self.main_model_part.GetRootModelPart()) ParallelFillCommunicator.Execute() if KratosMPI.mpi.rank == 0: print("MPI communicators constructed.") print("MPI model reading finished.")
def ImportModelPart(self): print("::[Pfem Fluid Solver]:: Model reading starts.") self.computing_model_part_name = "fluid_computing_domain" if(self.settings["model_import_settings"]["input_type"].GetString() == "mdpa"): print(" Importing input model part...") KratosMultiphysics.ModelPartIO(self.settings["model_import_settings"]["input_filename"].GetString()).ReadModelPart(self.main_model_part) print(" Import input model part.") # Auxiliary Kratos parameters object to be called by the CheckAndPepareModelProcess params = KratosMultiphysics.Parameters("{}") params.AddEmptyValue("computing_model_part_name").SetString(self.computing_model_part_name) params.AddValue("problem_domain_sub_model_part_list",self.settings["problem_domain_sub_model_part_list"]) params.AddValue("processes_sub_model_part_list",self.settings["processes_sub_model_part_list"]) if( self.settings.Has("bodies_list") ): params.AddValue("bodies_list",self.settings["bodies_list"]) # CheckAndPrepareModelProcess creates the fluid_computational model part import check_and_prepare_model_process_fluid check_and_prepare_model_process_fluid.CheckAndPrepareModelProcess(self.main_model_part, params).Execute() # Set Properties to nodes : Deprecated #self.SetProperties() # Set buffer size self.main_model_part.SetBufferSize( self.settings["buffer_size"].GetInt() ) current_buffer_size = self.main_model_part.GetBufferSize() if(self.GetMinimumBufferSize() > current_buffer_size): current_buffer_size = self.GetMinimumBufferSize() self.main_model_part.SetBufferSize( current_buffer_size ) # Fill buffer delta_time = self.main_model_part.ProcessInfo[KratosMultiphysics.DELTA_TIME] time = self.main_model_part.ProcessInfo[KratosMultiphysics.TIME] time = time - delta_time * (current_buffer_size) self.main_model_part.ProcessInfo.SetValue(KratosMultiphysics.TIME, time) for size in range(0, current_buffer_size): step = size - (current_buffer_size -1) self.main_model_part.ProcessInfo.SetValue(KratosMultiphysics.STEP, step) time = time + delta_time #delta_time is computed from previous time in process_info self.main_model_part.CloneTimeStep(time) self.main_model_part.ProcessInfo[KratosMultiphysics.IS_RESTARTED] = False elif(self.settings["model_import_settings"]["input_type"].GetString() == "rest"): problem_path = os.getcwd() restart_path = os.path.join(problem_path, self.settings["model_import_settings"]["input_filename"].GetString() + "__" + self.settings["model_import_settings"]["input_file_label"].GetString() ) if(os.path.exists(restart_path+".rest") == False): print(" rest file does not exist , check the restart step selected ") print(" Load Restart file: ", self.settings["model_import_settings"]["input_filename"].GetString() + "__" + self.settings["model_import_settings"]["input_file_label"].GetString()) # set serializer flag self.serializer_flag = SerializerTraceType.SERIALIZER_NO_TRACE # binary # self.serializer_flag = SerializerTraceType.SERIALIZER_TRACE_ERROR # ascii # self.serializer_flag = SerializerTraceType.SERIALIZER_TRACE_ALL # ascii serializer = Serializer(restart_path, self.serializer_flag) serializer.Load(self.main_model_part.Name, self.main_model_part) print(" Load input restart file.") self.main_model_part.ProcessInfo[KratosMultiphysics.IS_RESTARTED] = True print(self.main_model_part) else: raise Exception("Other input options are not yet implemented.") print ("::[Pfem Fluid Solver]:: Model reading finished.")