def _ExecuteAfterReading(self): self.computing_model_part_name = "computing_domain" #this submodelpart will be labeled with KratosMultiphysics.ACTIVE flag, you can recover it checking the flag. # 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 solid_computational model part import check_and_prepare_model_process_solid check_and_prepare_model_process_solid.CheckAndPrepareModelProcess( self.main_model_part, params).Execute() # Constitutive law import import constitutive_law_python_utility as constitutive_law_utils constitutive_law = constitutive_law_utils.ConstitutiveLawUtility( self.main_model_part, self.main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE]) constitutive_law.Initialize() print(" Constitutive law initialized.")
def _import_materials(self): # Assign material to model_parts (if Materials.json exists) import process_factory if(os.path.isfile("Materials.json") or self.input_manager.HasMaterialFile()): MaterialParameters = self.input_manager.GetMaterialParameters() if MaterialParameters.Has("material_models_list"): import KratosMultiphysics.ConstitutiveModelsApplication as KratosMaterials domain_model = self.model.GetModel() assign_materials_processes = process_factory.KratosProcessFactory(domain_model).ConstructListOfProcesses(MaterialParameters["material_models_list"]) for process in assign_materials_processes: process.Execute() self.model.CleanModel() elif os.path.isfile("materials.py"): # legacy import constitutive_law_python_utility as constitutive_law_utils constitutive_law = constitutive_law_utils.ConstitutiveLawUtility(self.main_model_part, self.process_info[KratosMultiphysics.SPACE_DIMENSION]) constitutive_law.Initialize() self.model.CleanModel() print("::[-----Material------]:: Reading file: materials.py ") else: print("No Materials.json or Materials.py found ")
def _import_materials(self): # Assign material to model_parts (if Materials.json exists) import process_factory if os.path.isfile("Materials.json"): materials_file = open("Materials.json",'r') MaterialParameters = KratosMultiphysics.Parameters(materials_file.read()) if(MaterialParameters.Has("material_models_list")): import KratosMultiphysics.ConstitutiveModelsApplication as KratosMaterials domain_model = self.model.GetModel() assign_materials_processes = process_factory.KratosProcessFactory(domain_model).ConstructListOfProcesses( MaterialParameters["material_models_list"] ) for process in assign_materials_processes: process.Execute() elif os.path.isfile("materials.py"): # legacy import constitutive_law_python_utility as constitutive_law_utils constitutive_law = constitutive_law_utils.ConstitutiveLawUtility(self.main_model_part, self.process_info[KratosMultiphysics.SPACE_DIMENSION]); constitutive_law.Initialize(); problem_path = os.getcwd() print(" Reading constitutive law from file :" + os.path.join(problem_path, "materials") + ".py ") else: print(" No Materials.json or Materials.py found ")
def _import_constitutive_laws(self): # Constitutive law import import constitutive_law_python_utility as constitutive_law_utils constitutive_law = constitutive_law_utils.ConstitutiveLawUtility( self.main_model_part, self.main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE]) constitutive_law.Initialize() return True
def _import_constitutive_laws(self): if os.path.isfile("materials.py"): # Constitutive law import import constitutive_law_python_utility as constitutive_law_utils constitutive_law = constitutive_law_utils.ConstitutiveLawUtility(self.main_model_part, self.main_model_part.ProcessInfo[KratosMultiphysics.SPACE_DIMENSION]); constitutive_law.Initialize(); return True else: return False
def ImportModelPart(self): print("::[Mechanical Solver]:: Model reading starts.") if (self.settings["model_import_settings"]["input_type"].GetString() == "mdpa"): # Here it would be the place to import restart data if required 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 aux_params = Parameters("{}") aux_params.AddValue( "problem_domain_sub_model_part_list", self.settings["problem_domain_sub_model_part_list"]) aux_params.AddValue("processes_sub_model_part_list", self.settings["processes_sub_model_part_list"]) # CheckAndPrepareModelProcess creates the solid_computational_model_part import check_and_preparemodel_process check_and_preparemodel_process.CheckAndPrepareModelProcess( self.main_model_part, aux_params).Execute() # Constitutive law import import constitutive_law_python_utility as constitutive_law_utils constitutive_law = constitutive_law_utils.ConstitutiveLawUtility( self.main_model_part, self.main_model_part.ProcessInfo[DOMAIN_SIZE]) constitutive_law.Initialize() print(" Constitutive law initialized.") 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("::[Mechanical Solver]:: Model reading finished.")
# set the buffer size model_part.SetBufferSize(buffer_size) # Note: the buffer size should be set once the mesh is read for the first time print("::[KSM Simulation]:: Reading -END- ") model_part.ProcessInfo[LOAD_RESTART] = 0 # set the degrees of freedom solver_constructor.AddDofs(model_part, SolverSettings) # set the constitutive law import constitutive_law_python_utility as constitutive_law_utils constitutive_law = constitutive_law_utils.ConstitutiveLawUtility( model_part, domain_size) constitutive_law.Initialize() else: print("::[KSM Simulation]:: Reading -RESTART- (RESTART FILE ", restart_step, ")- ") # reading the model from the restart file problem_restart.Load(restart_step) print("::[KSM Simulation]:: Reading -END- ") model_part.ProcessInfo[LOAD_RESTART] = 1 # remove results, restart, graph and list posterior files
# Setting up the buffer size spheres_model_part.SetBufferSize(1) cluster_model_part.SetBufferSize(1) DEM_inlet_model_part.SetBufferSize(1) rigid_face_model_part.SetBufferSize(FEM_main_step_solver.buffer_size) #DEMFFEM # Adding dofs solver.AddDofs(spheres_model_part) solver.AddDofs(cluster_model_part) solver.AddDofs(DEM_inlet_model_part) FEM_solver_constructor.AddDofs(rigid_face_model_part, FEMSolverSettings) #Utilities # set the constitutive law constitutive_law = constitutive_law_utils.ConstitutiveLawUtility( rigid_face_model_part, DEM_parameters["Dimension"].GetInt()) constitutive_law.Initialize() conditions = condition_utils.ConditionsUtility( rigid_face_model_part, DEM_parameters["Dimension"].GetInt(), FEM_general_variables.Incremental_Displacement, FEM_general_variables.Incremental_Load, FEMSolverSettings.RotationDofs) # Creating necessary directories main_path = os.getcwd() [post_path, data_and_results, graphs_path, MPI_results] = procedures.CreateDirectories( str(main_path), str(DEM_parameters["problem_name"].GetString())) os.chdir(main_path) KRATOSprint("\nInitializing Problem...")
def ImportModelPart(self): print("::[Mechanical Solver]:: Model reading starts.") 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) print(" Import input 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"]) ######### TO BE REVIEWED AS SOON AS THE REPLACE SETTINGS ARE STATED ########### #~ #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":"VMS3D4N", #~ "condition_name": "MonolithicWallCondition3D" #~ } #~ """) #~ elif(self.main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE] == 2): #~ self.settings["element_replace_settings"] = KratosMultiphysics.Parameters(""" #~ { #~ "element_name":"VMS2D3N", #~ "condition_name": "MonolithicWallCondition2D" #~ } #~ """) #~ 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_preparemodel_process #~ check_and_preparemodel_process.CheckAndPrepareModelProcess(self.main_model_part, aux_params).Execute() ###### TODO: This manner does not allow to set different materials (unique material model)... # Set density, Young modulus and Poisson ratio to the nodes for el in self.main_model_part.Elements: density = el.Properties.GetValue(KratosMultiphysics.DENSITY) young_modulus = el.Properties.GetValue( KratosMultiphysics.YOUNG_MODULUS) poisson_ratio = el.Properties.GetValue( KratosMultiphysics.POISSON_RATIO) break KratosMultiphysics.VariableUtils().SetScalarVar( KratosMultiphysics.DENSITY, density, self.main_model_part.Nodes) KratosMultiphysics.VariableUtils().SetScalarVar( KratosMultiphysics.YOUNG_MODULUS, young_modulus, self.main_model_part.Nodes) KratosMultiphysics.VariableUtils().SetScalarVar( KratosMultiphysics.POISSON_RATIO, poisson_ratio, self.main_model_part.Nodes) print(" Density, Young modulus and Poisson ratio set.") # Constitutive law import import constitutive_law_python_utility as constitutive_law_utils constitutive_law = constitutive_law_utils.ConstitutiveLawUtility( self.main_model_part, self.main_model_part.ProcessInfo[ KratosMultiphysics.DOMAIN_SIZE]) constitutive_law.Initialize() print(" Constitutive law initialized.") 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("::[Mechanical Solver]:: Model reading finished.")
def ImportModelPart(self): #add variables (always before importing the model part) self.AddVariables() if (self.settings["model_import_settings"]["input_type"].GetString() == "mdpa"): #here it would be the place to import restart data if required kratos_core.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 = kratos_core.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 could do things to prepare the model part. Probably not needed for the structure self.compute_model_part = self.main_model_part ##here we must construct correctly the constitutive law print( "don't forget constructing the constitutive law!!!!!!!!!!!!!!") import constitutive_law_python_utility constitutive_law = constitutive_law_python_utility.ConstitutiveLawUtility( main_model_part, self.settings["DomainSize"]) constitutive_law.Initialize() elif (self.settings["model_import_settings"]["input_type"].GetString() == "other_model_part"): ##generate from another ModelPart origin_model_part = self.main_model_part.GetSubModelPart( self.settings["model_import_settings"] ["origin_model_part_name"].GetString()) new_model_part_name = self.settings["model_import_settings"][ "new_model_part_name"].GetString() if (not self.main_model_part.HasSubModelPart(new_model_part_name)): self.main_model_part.CreateSubModelPart(new_model_part_name) new_model_part = self.main_model_part.GetSubModelPart( new_model_part_name) #fill the model_part to be used by the termal solver kratos_core.ConnectivityPreserveModeler().GenerateModelPart( origin_model_part, new_model_part, "PlasticConvectionDiffusionElement3D", "PlasticThermalFace3D") #here we could do things to prepare the model part. Probably not needed for the structure self.compute_model_part = self.main_model_part ##here we must construct correctly the constitutive law print( "don't forget constructing the constitutive law!!!!!!!!!!!!!!") import constitutive_law_python_utility constitutive_law = constitutive_law_python_utility.ConstitutiveLawUtility( main_model_part, self.settings["DomainSize"]) constitutive_law.Initialize() else: raise Exception("input from restart 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") #add dofs (always after importing the model part) (it must be integrated in the ImportModelPart) self.AddDofs()
# Setting up the buffer size spheres_model_part.SetBufferSize(1) cluster_model_part.SetBufferSize(1) DEM_inlet_model_part.SetBufferSize(1) rigid_face_model_part.SetBufferSize(FEM_main_step_solver.buffer_size) #DEMFFEM # Adding dofs solver.AddDofs(spheres_model_part) solver.AddDofs(cluster_model_part) solver.AddDofs(DEM_inlet_model_part) FEM_solver_constructor.AddDofs(rigid_face_model_part, FEMSolverSettings) #Utilities # set the constitutive law constitutive_law = constitutive_law_utils.ConstitutiveLawUtility( rigid_face_model_part, DEM_parameters.Dimension) constitutive_law.Initialize() conditions = condition_utils.ConditionsUtility( rigid_face_model_part, DEM_parameters.Dimension, FEM_general_variables.Incremental_Displacement, FEM_general_variables.Incremental_Load, FEMSolverSettings.RotationDofs) # Creating necessary directories main_path = os.getcwd() [post_path, data_and_results, graphs_path, MPI_results] = procedures.CreateDirectories(str(main_path), str(DEM_parameters.problem_name)) os.chdir(main_path) KRATOSprint("\nInitializing Problem...")