Merge pull request #13315 from KratosMultiphysics/core/deprecate-parameters-iter

[Core] Remove deprecated iteration over `Parameters`

Author: matekelemen

applications/CoSimulationApplication/python_scripts/convergence_criteria/absolute_norm_energy_conjugate.py

@@ -29,7 +29,7 @@ def __init__(self, settings, solvers):
         # Determine if we are looking at the energy difference between two domains (solvers), or just one
         self.solver_vec = [solvers[settings["solver"].GetString()]]
         is_dual_domain = False
-        for criteria_option in settings["criteria_options"]:
+        for criteria_option in settings["criteria_options"].values():
             if criteria_option.GetString() == "domain_difference":
                 is_dual_domain = True
                 break

applications/DEMApplication/python_scripts/materials_assignation_utility.py

@@ -69,7 +69,7 @@ def AssignPropertiesToEntities(self):
             if pair[1].IsString():
                 material_name_in_assignation_table = pair[1].GetString()
                 material_id = None
-                for material in list_of_materials:
+                for material in list_of_materials.values():
                     material_name_in_materials_list = material["material_name"].GetString()
                     if material_name_in_assignation_table == material_name_in_materials_list:
                         material_id = material["material_id"].GetInt()

applications/FluidDynamicsHydraulicsApplication/python_scripts/navier_stokes_two_fluid_hydraulic_fractional_solver.py

@@ -79,7 +79,7 @@ def GetDefaultParameters(cls):
                     "dynamic_tau" : 1.0,
                     "tau_nodal":true
                 }
-            },                                                                       
+            },
             "distance_reinitialization_type" :"variational",
             "distance_reinitialization_settings":{
             },
@@ -105,7 +105,7 @@ def __init__(self, model, custom_settings):
         self.condition_name = "TwoFluidNavierStokesWallCondition"
         self.element_integrates_in_time = True
         self.element_has_nodal_properties = True
-        
+
         # Set the levelset characteristic variables and add them to the convection settings
         # These are required to be set as some of the auxiliary processes admit user-defined variables
         self._levelset_variable = KratosMultiphysics.DISTANCE
@@ -115,10 +115,10 @@ def __init__(self, model, custom_settings):
         self.settings["levelset_convection_settings"].AddEmptyValue("levelset_gradient_variable_name").SetString("DISTANCE_GRADIENT")
         self.settings["levelset_convection_settings"].AddEmptyValue("levelset_convection_variable_name").SetString("VELOCITY")
         self.settings["levelset_convection_settings"].AddEmptyValue("convection_model_part_name").SetString("LevelSetConvectionModelPart")
-       
+
         self.settings["fractional_splitting_settings"].AddEmptyValue("model_part_name").SetString(self.main_model_part.Name )
-               
-       
+
+
         dynamic_tau = self.settings["formulation"]["dynamic_tau"].GetDouble()
         self.main_model_part.ProcessInfo.SetValue(KratosMultiphysics.DYNAMIC_TAU, dynamic_tau)
 
@@ -220,25 +220,25 @@ def InitializeSolutionStep(self):
         # Inlet and outlet water discharge is calculated for current time step, first discharge and the considering the time step inlet and outlet volume is calculated
         if self.mass_source:
             self._ComputeStepInitialWaterVolume()
-        
+
         # Recompute the BDF2 coefficients
         (self.time_discretization).ComputeAndSaveBDFCoefficients(self.GetComputingModelPart().ProcessInfo)
 
         # STEP I: NS Fractional part 1
-        # Perform the pure convection of the fractional velocity which corresponds to the first part of the NS fractional splitting. 
+        # Perform the pure convection of the fractional velocity which corresponds to the first part of the NS fractional splitting.
         self.__PerformNSFractionalSplitting()
         KratosMultiphysics.Logger.PrintInfo(self.__class__.__name__, "Navier Stokes fractional convection part is performed.")
-       
-        # STEP II: Convect the free surface according to the fractional velocity 
-        # Before doing this second step, the fractional velocity data is copied to the velocity data since the level set convection process takes velocity variable as convection variable. 
+
+        # STEP II: Convect the free surface according to the fractional velocity
+        # Before doing this second step, the fractional velocity data is copied to the velocity data since the level set convection process takes velocity variable as convection variable.
         # And the previous previous velocity is copied in an auxiliar variable
         KratosMultiphysics.VariableUtils().CopyModelPartNodalVar(KratosCFD.FRACTIONAL_VELOCITY,KratosMultiphysics.VELOCITY, self.main_model_part, self.main_model_part, 0, 0)
         KratosMultiphysics.VariableUtils().CopyModelPartNodalVar(KratosMultiphysics.VELOCITY,KratosCFD.AUXILIAR_VECTOR_VELOCITY, self.main_model_part, self.main_model_part, 0, 0)
 
         self.__PerformLevelSetConvection()
         KratosMultiphysics.Logger.PrintInfo(self.__class__.__name__, "Level-set convection is performed.")
 
-        # After the convection process, the velocity is copied back to the original state. 
+        # After the convection process, the velocity is copied back to the original state.
         KratosMultiphysics.VariableUtils().CopyModelPartNodalVar(KratosCFD.AUXILIAR_VECTOR_VELOCITY,KratosMultiphysics.VELOCITY, self.main_model_part, self.main_model_part, 0, 0)
 
         # Perform distance correction to prevent ill-conditioned cuts
@@ -272,14 +272,14 @@ def FinalizeSolutionStep(self):
 
         # Prepare distance correction for next step
         self._GetDistanceModificationProcess().ExecuteFinalizeSolutionStep()
-        
-        # FinalizeSolutionStep of Navier-Stokes strategy 
+
+        # FinalizeSolutionStep of Navier-Stokes strategy
         self._GetSolutionStrategy().FinalizeSolutionStep()
 
     def _ComputeStepInitialWaterVolume(self):
-      
-        # This function calculates the theoretical water volume at each time step. 
-        # Reminder: Despite adding the source term to both air and water, the absolute volume error 
+
+        # This function calculates the theoretical water volume at each time step.
+        # Reminder: Despite adding the source term to both air and water, the absolute volume error
         # is referenced to the water volume, since what is lost from water is gained by air and vice versa.
 
         # Here the initial water volume of the system is calculated without considering inlet and outlet flow rate
@@ -299,8 +299,8 @@ def _ComputeStepInitialWaterVolume(self):
         self.__initial_water_system_volume = system_water_volume
 
     def _ComputeVolumeError(self):
-        # In this function, the volume of the cut elements is calculated, 
-        # corresponding to the portions of water and air volumes, as this is the domain where the source term will be added. 
+        # In this function, the volume of the cut elements is calculated,
+        # corresponding to the portions of water and air volumes, as this is the domain where the source term will be added.
         # Meanwhile, the absolute error is calculated within the water domain
 
         if self.mass_source:
@@ -336,7 +336,7 @@ def __PerformNSFractionalSplitting(self):
         self._GetNSFractionalSplittingProcess().Execute()
         # Trasfer velocity slip condition to fractional velocity
         self.__SlipConditonFractionalFixity()
-    # TODO: Remove those methods as soon as a new  hydraulic slip process is done. 
+    # TODO: Remove those methods as soon as a new  hydraulic slip process is done.
     def __SlipConditonFractionalFixity(self):
         for node in self.GetComputingModelPart().Nodes:
             if node.Is(KratosMultiphysics.SLIP):
@@ -345,7 +345,7 @@ def __SlipConditonFractionalFixity(self):
                 v= node.GetSolutionStepValue(KratosCFD.FRACTIONAL_VELOCITY)
                 v_prooj = self.DotProduct(v,n)
                 v-= v_prooj*n
-                node.SetSolutionStepValue(KratosCFD.FRACTIONAL_VELOCITY,v) 
+                node.SetSolutionStepValue(KratosCFD.FRACTIONAL_VELOCITY,v)
     def VelocityBoundaryConditionFractional(self, fractional_velocity_componentes, velocity_components):
         for node in self.GetComputingModelPart().Nodes:
             if node.IsFixed(velocity_components):
@@ -381,7 +381,7 @@ def GetAuxMaterialsFileName(mat_file_name, prop_id):
 
             if data_comm.Rank() == 0:
                 # Create and read an auxiliary materials file for each one of the fields (only on one rank)
-                for i_material in materials["properties"]:
+                for i_material in materials["properties"].values():
                     aux_materials = KratosMultiphysics.Parameters()
                     aux_materials.AddEmptyArray("properties")
                     aux_materials["properties"].Append(i_material)
@@ -393,7 +393,7 @@ def GetAuxMaterialsFileName(mat_file_name, prop_id):
             data_comm.Barrier()
 
             # read the files on all ranks
-            for i_material in materials["properties"]:
+            for i_material in materials["properties"].values():
                 aux_materials_filename = GetAuxMaterialsFileName(materials_filename, i_material["properties_id"].GetInt())
                 aux_material_settings = KratosMultiphysics.Parameters("""{"Parameters": {"materials_filename": ""}} """)
                 aux_material_settings["Parameters"]["materials_filename"].SetString(aux_materials_filename)
@@ -403,7 +403,7 @@ def GetAuxMaterialsFileName(mat_file_name, prop_id):
 
             if data_comm.Rank() == 0:
                 # remove aux files after every rank read them
-                for i_material in materials["properties"]:
+                for i_material in materials["properties"].values():
                     aux_materials_filename = GetAuxMaterialsFileName(materials_filename, i_material["properties_id"].GetInt())
                     KratosUtilities.DeleteFileIfExisting(aux_materials_filename)
 

applications/FluidDynamicsHydraulicsApplication/python_scripts/navier_stokes_two_fluid_hydraulic_solver.py

@@ -466,7 +466,7 @@ def GetAuxMaterialsFileName(mat_file_name, prop_id):
 
             if data_comm.Rank() == 0:
                 # Create and read an auxiliary materials file for each one of the fields (only on one rank)
-                for i_material in materials["properties"]:
+                for i_material in materials["properties"].values():
                     aux_materials = KratosMultiphysics.Parameters()
                     aux_materials.AddEmptyArray("properties")
                     aux_materials["properties"].Append(i_material)
@@ -478,7 +478,7 @@ def GetAuxMaterialsFileName(mat_file_name, prop_id):
             data_comm.Barrier()
 
             # read the files on all ranks
-            for i_material in materials["properties"]:
+            for i_material in materials["properties"].values():
                 aux_materials_filename = GetAuxMaterialsFileName(materials_filename, i_material["properties_id"].GetInt())
                 aux_material_settings = KratosMultiphysics.Parameters("""{"Parameters": {"materials_filename": ""}} """)
                 aux_material_settings["Parameters"]["materials_filename"].SetString(aux_materials_filename)
@@ -488,7 +488,7 @@ def GetAuxMaterialsFileName(mat_file_name, prop_id):
 
             if data_comm.Rank() == 0:
                 # remove aux files after every rank read them
-                for i_material in materials["properties"]:
+                for i_material in materials["properties"].values():
                     aux_materials_filename = GetAuxMaterialsFileName(materials_filename, i_material["properties_id"].GetInt())
                     KratosUtilities.DeleteFileIfExisting(aux_materials_filename)
 

applications/GeoMechanicsApplication/python_scripts/geomechanics_solver.py

@@ -207,10 +207,10 @@ def PrepareModelPart(self):
         self.main_model_part.ProcessInfo.SetValue(KratosMultiphysics.STEP, 0)
         self.computing_model_part_name = "porous_computational_model_part"
 
-        sub_model_part_names = [f"sub_{name.GetString()}" for name in self.settings["body_domain_sub_model_part_list"]]
+        sub_model_part_names = [f"sub_{name.GetString()}" for name in self.settings["body_domain_sub_model_part_list"].values()]
         self.body_domain_sub_sub_model_part_list = KratosMultiphysics.Parameters(json.dumps(sub_model_part_names))
 
-        sub_model_part_names = [f"sub_{name.GetString()}" for name in self.settings["loads_sub_model_part_list"]]
+        sub_model_part_names = [f"sub_{name.GetString()}" for name in self.settings["loads_sub_model_part_list"].values()]
         self.loads_sub_sub_model_part_list = KratosMultiphysics.Parameters(json.dumps(sub_model_part_names))
 
         if not self.main_model_part.ProcessInfo[KratosMultiphysics.IS_RESTARTED]:
@@ -357,7 +357,7 @@ def _add_water_variables(self):
         self.main_model_part.AddNodalSolutionStepVariable(GeoMechanicsApplication.NORMAL_FLUID_FLUX)
         # Add variables for the water conditions
         self.main_model_part.AddNodalSolutionStepVariable(GeoMechanicsApplication.HYDRAULIC_DISCHARGE)
-        
+
         # Add integration \ gauss point values that will likely need extrapolating to node
         self.main_model_part.AddNodalSolutionStepVariable(GeoMechanicsApplication.HYDRAULIC_HEAD)
         self.main_model_part.AddNodalSolutionStepVariable(KratosMultiphysics.CAUCHY_STRESS_TENSOR)

applications/MPMApplication/python_scripts/mpm_analysis.py

@@ -44,7 +44,7 @@ def _AddFrictionAuxiliaryVariables(self, project_parameters):
         friction_active = False
 
         for proc_list in project_parameters["processes"].values():
-            for proc in proc_list:
+            for proc in proc_list.values():
                 if proc.Has("process_name") and proc["process_name"].GetString() == "ApplyMPMSlipBoundaryProcess":
                     proc_params = proc["Parameters"]
 

applications/RomApplication/python_scripts/rom_analysis.py

@@ -28,7 +28,7 @@ def _CreateSolver(self):
                 for name in self.project_parameters["output_processes"].keys():
                     if name=="rom_output":
                         rom_output_parameters = self.project_parameters["output_processes"]["rom_output"]
-                        for parameter_set in rom_output_parameters:
+                        for parameter_set in rom_output_parameters.values():
                             if parameter_set["python_module"].GetString() == "calculate_rom_basis_output_process":
                                 if parameter_set["Parameters"].Has("rom_basis_output_name"):
                                     self.rom_basis_output_name = parameter_set["Parameters"]["rom_basis_output_name"].GetString()
@@ -261,7 +261,7 @@ def ModifyAfterSolverInitialize(self):
                 self.__petrov_galerkin_training_utility = PetrovGalerkinTrainingUtility(
                     self._GetSolver(),
                     self.rom_parameters)
-                
+
 
         def ModifyInitialGeometry(self):
             super().ModifyInitialGeometry()
@@ -277,7 +277,7 @@ def ModifyInitialGeometry(self):
                 self._GetSolver()._GetBuilderAndSolver().SetDecoderParameters(computing_model_part, len(NNLayers), SVDPhiMatrices[0], SVDPhiMatrices[1], SVDPhiMatrices[2], refSnapshot)
                 for i, layer in enumerate(NNLayers):
                     self._GetSolver()._GetBuilderAndSolver().SetNNLayer(computing_model_part, i, layer)
-                
+
                 nodal_unknown_names= self.project_parameters["solver_settings"]["rom_settings"]["nodal_unknowns"].GetStringArray()
                 nodal_dofs = len(nodal_unknown_names)
                 nodal_unknowns=[]
@@ -302,7 +302,7 @@ def ModifyInitialGeometry(self):
                 computing_model_part.SetValue(KratosROM.ROM_SOLUTION_BASE, KratosMultiphysics.Vector(q))
                 computing_model_part.SetValue(KratosROM.ROM_SOLUTION_TOTAL, KratosMultiphysics.Vector(q))
                 computing_model_part.SetValue(KratosROM.ROM_SOLUTION_INCREMENT, KratosMultiphysics.Vector(np.zeros_like(q)))
-                
+
                 s_init = np.array(self._GetSolver()._GetBuilderAndSolver().RunDecoder(computing_model_part, q))
                 print(s_init.shape)
 
@@ -311,7 +311,7 @@ def ModifyInitialGeometry(self):
                     for nodal_var in nodal_unknowns:
                         node.SetSolutionStepValue(nodal_var, s_init[i])
                         i+=1
-                        
+
                 computing_model_part.SetValue(KratosROM.SOLUTION_BASE, KratosMultiphysics.Vector(s_init))
 
                 # Initialize nodal ROM_BASIS to zeros

applications/SwimmingDEMApplication/python_scripts/swimming_sphere_strategy.py

@@ -74,7 +74,7 @@ def GetRotationalSchemeInstance(self, class_name):
 
     def GetHydrodynamicLawParametersIfItExists(self, properties):
         if self.project_parameters.Has('properties'):
-            for p in self.project_parameters["properties"]:
+            for p in self.project_parameters["properties"].values():
                 return p['hydrodynamic_law_parameters']
         return None
 

applications/SystemIdentificationApplication/python_scripts/responses/damage_detection_response.py

@@ -58,7 +58,7 @@ def __init__(self, name: str, model: Kratos.Model, parameters: Kratos.Parameters
 
         # reading test analsis list
         self.list_of_test_analysis_data: 'list[tuple[ExecutionPolicyDecorator, DataIO, str, float]]' = []
-        for params in parameters["test_analysis_list"]:
+        for params in parameters["test_analysis_list"].values():
             params.ValidateAndAssignDefaults(default_settings["test_analysis_list"][0])
             primal_analysis_name = params["primal_analysis_name"].GetString()
             sensor_measurement_data_file_name = params["sensor_measurement_csv_file"].GetString()
@@ -92,7 +92,7 @@ def Initialize(self) -> None:
 
     def Check(self) -> None:
         pass
-    
+
     def Finalize(self) -> None:
         self.adjoint_analysis.Finalize()
 

kratos/python/add_kratos_parameters_to_python.cpp

@@ -127,7 +127,10 @@ void  AddKratosParametersToPython(pybind11::module& m)
     .def("__getitem__", GetValue)
     .def("__setitem__", &Parameters::SetArrayItem)
     .def("__getitem__", GetArrayItem)
-    .def("__iter__", [](Parameters& self){ return py::make_iterator(self.begin(), self.end()); } , py::keep_alive<0,1>())
+    .def("__iter__", [](Parameters& self){
+            KRATOS_ERROR << "iterating through Parameters is ambiguous. Use \"keys\", \"values\" or \"items\" instead.";
+            return py::make_iterator(self.begin(), self.end());
+        } , py::keep_alive<0,1>())
     .def("items", &items )
     .def("keys", &keys )
     .def("values", &values )