def testNutYPlusWallFunctionUpdateProcess(self): settings = Kratos.Parameters(r''' [ { "kratos_module" : "KratosMultiphysics.RANSApplication", "python_module" : "cpp_process_factory", "process_name" : "NutYPlusWallFunctionUpdateProcess", "Parameters" : { "model_part_name" : "FluidModelPart" } } ]''') KratosRANS.RansTestUtilities.RandomFillConditionVariable( self.model.GetModelPart("FluidModelPart"), KratosRANS.RANS_Y_PLUS, 10.0, 100.0) test_variables = ["TURBULENT_VISCOSITY", "VISCOSITY"] test_model_part_name = "FluidModelPart.AutomaticInlet2D_inlet" test_file_name = "nut_y_plus_wall_function_test_output" CustomProcessTest.__AddJsonCheckProcess(settings, test_variables, test_model_part_name, test_file_name) # CustomProcessTest.__AddJsonOutputProcess(settings, test_variables, test_model_part_name, test_file_name) factory = KratosProcessFactory(self.model) self.process_list = factory.ConstructListOfProcesses(settings) self.__ExecuteProcesses()
def testOmegaTurbulentMixingLengthInletProcess(self): settings = Kratos.Parameters(r''' [ { "kratos_module" : "KratosMultiphysics.RANSApplication", "python_module" : "cpp_process_factory", "process_name" : "OmegaTurbulentMixingLengthInletProcess", "Parameters" : { "model_part_name" : "FluidModelPart" } } ]''') Kratos.VariableUtils().AddDof( KratosRANS.TURBULENT_SPECIFIC_ENERGY_DISSIPATION_RATE, self.model_part) test_variables = ["TURBULENT_SPECIFIC_ENERGY_DISSIPATION_RATE"] test_model_part_name = "FluidModelPart.AutomaticInlet2D_inlet" test_file_name = "omega_turbulent_mixing_length_inlet_test_output" CustomProcessTest.__AddJsonCheckProcess(settings, test_variables, test_model_part_name, test_file_name) # CustomProcessTest.__AddJsonOutputProcess(settings, test_variables, test_model_part_name, test_file_name) factory = KratosProcessFactory(self.model) self.process_list = factory.ConstructListOfProcesses(settings) self.__ExecuteProcesses() for node in self.model.GetModelPart(test_model_part_name).Nodes: self.assertEqual( node.IsFixed( KratosRANS.TURBULENT_SPECIFIC_ENERGY_DISSIPATION_RATE), True)
def testWallDistanceCalculationProcess(self): settings = Kratos.Parameters(r''' [ { "kratos_module" : "KratosMultiphysics.RANSApplication", "python_module" : "cpp_process_factory", "process_name" : "WallDistanceCalculationProcess", "Parameters" : { "main_model_part_name" : "FluidModelPart", "wall_model_part_name" : "FluidModelPart.Slip2D.Slip2D_walls", "echo_level" : 0, "max_distance" : 1e+30, "max_levels" : 14, "re_calculate_at_each_time_step" : false } } ]''') test_variables = ["DISTANCE"] test_model_part_name = "FluidModelPart" test_file_name = "wall_distance_calculation_test_output" CustomProcessTest.__AddJsonCheckProcess(settings, test_variables, test_model_part_name, test_file_name) # CustomProcessTest.__AddJsonOutputProcess(settings, test_variables, test_model_part_name, test_file_name) CalculateNormalsOnConditions(self.model_part) factory = KratosProcessFactory(self.model) self.process_list = factory.ConstructListOfProcesses(settings) self.__ExecuteProcesses()
def testKTurbulentIntensityInletProcess(self): settings = Kratos.Parameters(r''' [ { "kratos_module" : "KratosMultiphysics.RANSApplication", "python_module" : "cpp_process_factory", "process_name" : "KTurbulentIntensityInletProcess", "Parameters" : { "model_part_name" : "FluidModelPart.AutomaticInlet2D_inlet", "turbulent_intensity" : 0.01 } } ]''') Kratos.VariableUtils().AddDof(KratosRANS.TURBULENT_KINETIC_ENERGY, self.model_part) test_variables = ["TURBULENT_KINETIC_ENERGY"] test_model_part_name = "FluidModelPart.AutomaticInlet2D_inlet" test_file_name = "k_turbulent_intensity_inlet_test_output" CustomProcessTest.__AddJsonCheckProcess(settings, test_variables, test_model_part_name, test_file_name) # CustomProcessTest.__AddJsonOutputProcess(settings, test_variables, test_model_part_name, test_file_name) factory = KratosProcessFactory(self.model) self.process_list = factory.ConstructListOfProcesses(settings) self.__ExecuteProcesses() for node in self.model.GetModelPart(test_model_part_name).Nodes: self.assertEqual(node.IsFixed(KratosRANS.TURBULENT_KINETIC_ENERGY), True)
def testClipScalarVariableProcess(self): self.__CreateModel() settings = Kratos.Parameters(r''' [ { "kratos_module" : "KratosMultiphysics.RANSApplication", "python_module" : "cpp_process_factory", "process_name" : "ClipScalarVariableProcess", "Parameters" : { "model_part_name" : "test", "variable_name" : "DENSITY", "min_value" : 0.5, "max_value" : 0.6 } } ]''') model_part = self.model["test"] for node in model_part.Nodes: density = node.GetSolutionStepValue(Kratos.DENSITY) node.SetSolutionStepValue(Kratos.DENSITY, 0, math.pow(-1, node.Id) * density) factory = KratosProcessFactory(self.model) self.process_list = factory.ConstructListOfProcesses(settings) self.__ExecuteProcesses() for node in model_part.Nodes: density = node.GetSolutionStepValue(Kratos.DENSITY) self.assertEqual(density >= 0.5, True) self.assertEqual(density <= 0.6, True)
def _CreateProcesses(self, parameter_name, initialization_order): """Create a list of Processes This method is TEMPORARY to not break existing code It will be removed in the future """ list_of_processes = super(FluidTransportAnalysis, self)._CreateProcesses(parameter_name, initialization_order) if parameter_name == "processes": processes_block_names = ["constraints_process_list", "loads_process_list","auxiliar_process_list"] if len(list_of_processes) == 0: # Processes are given in the old format KratosMultiphysics.Logger.PrintInfo(self._GetSimulationName(), "Using the old way to create the processes, this will be removed!") from KratosMultiphysics.process_factory import KratosProcessFactory factory = KratosProcessFactory(self.model) for process_name in processes_block_names: if (self.project_parameters.Has(process_name) is True): list_of_processes += factory.ConstructListOfProcesses(self.project_parameters[process_name]) else: # Processes are given in the new format for process_name in processes_block_names: if (self.project_parameters.Has(process_name) is True): raise Exception("Mixing of process initialization is not alowed!") elif parameter_name == "output_processes": if self.project_parameters.Has("output_configuration"): gid_output= self._SetUpGiDOutput() list_of_processes += [gid_output,] else: raise NameError("wrong parameter name") return list_of_processes
def testComputeReactionsProcess(self): settings = Kratos.Parameters(r''' [ { "kratos_module" : "KratosMultiphysics.RANSApplication", "python_module" : "cpp_process_factory", "process_name" : "ComputeReactionsProcess", "Parameters" : { "model_part_name" : "FluidModelPart" } } ]''') KratosRANS.RansTestUtilities.RandomFillConditionVariable( self.model.GetModelPart("FluidModelPart"), KratosRANS.FRICTION_VELOCITY, 10.0, 100.0) test_variables = ["REACTION"] test_model_part_name = "FluidModelPart.Slip2D.Slip2D_walls" test_file_name = "compute_reactions_test_output" CustomProcessTest.__AddJsonCheckProcess(settings, test_variables, test_model_part_name, test_file_name) # CustomProcessTest.__AddJsonOutputProcess(settings, test_variables, test_model_part_name, test_file_name) factory = KratosProcessFactory(self.model) self.process_list = factory.ConstructListOfProcesses(settings) self.__ExecuteProcesses()
def testNutKEpsilonHighReCalculationProcess(self): self.__CreateModel() settings = Kratos.Parameters(r''' [ { "kratos_module" : "KratosMultiphysics.RANSApplication", "python_module" : "cpp_process_factory", "process_name" : "NutKEpsilonHighReCalculationProcess", "Parameters" : { "model_part_name" : "test", "echo_level" : 0, "c_mu" : 0.09 } } ]''') factory = KratosProcessFactory(self.model) self.process_list = factory.ConstructListOfProcesses(settings) self.__ExecuteProcesses() c_mu = 0.09 for node in self.model_part.Nodes: k = node.GetSolutionStepValue(KratosRANS.TURBULENT_KINETIC_ENERGY) epsilon = node.GetSolutionStepValue( KratosRANS.TURBULENT_ENERGY_DISSIPATION_RATE) node_value = node.GetSolutionStepValue(Kratos.TURBULENT_VISCOSITY) self.assertAlmostEqual(node_value, c_mu * k * k / epsilon, 9)
def Initialize(self): factory = KratosProcessFactory(self.GetBaseModelPart().GetModel()) self.auxiliar_process_list = factory.ConstructListOfProcesses( self.GetParameters()["auxiliar_process_list"]) for process in self.auxiliar_process_list: self.AddProcess(process) super().Initialize()
def testVectorAlignProcessNormal(self): self.__CreateModel() settings = Kratos.Parameters(r''' [ { "kratos_module" : "KratosMultiphysics.RANSApplication", "python_module" : "cpp_process_factory", "process_name" : "VectorAlignProcess", "Parameters" : { "model_part_name" : "test.submodelpart_1", "input_variable_name" : "VELOCITY", "output_variable_name" : "VELOCITY", "alignment_variable_name" : "NORMAL", "is_tangential_alignment" : false, "echo_level" : 0 } } ]''') node_ids = [1, 2, 3] check_values = [] for node in self.model_part.Nodes: if (node.Id in node_ids): normal = node.GetSolutionStepValue(Kratos.NORMAL) normal_magnitude = float( math.pow( normal[0] * normal[0] + normal[1] * normal[1] + normal[2] * normal[2], 0.5)) unit_normal = [ normal[0] / normal_magnitude, normal[1] / normal_magnitude, normal[2] / normal_magnitude ] vector = node.GetSolutionStepValue(Kratos.VELOCITY) vector_normal_magnitude = float(vector[0] * unit_normal[0] + vector[1] * unit_normal[1] + vector[2] * unit_normal[2]) check_values.append([ vector_normal_magnitude * unit_normal[0], vector_normal_magnitude * unit_normal[1], vector_normal_magnitude * unit_normal[2] ]) else: vector = node.GetSolutionStepValue(Kratos.VELOCITY) check_values.append( [float(vector[0]), float(vector[1]), float(vector[2])]) factory = KratosProcessFactory(self.model) self.process_list = factory.ConstructListOfProcesses(settings) self.__ExecuteProcesses() for node, value in zip(self.model_part.Nodes, check_values): node_value = node.GetSolutionStepValue(Kratos.VELOCITY) for i in range(3): self.assertAlmostEqual(node_value[i], value[i], 9)
def _CreateProcesses(self, parameter_name, initialization_order): """Create a list of Processes This method is TEMPORARY to not break existing code It will be removed in the future """ list_of_processes = super(StructuralMechanicsAnalysis, self)._CreateProcesses( parameter_name, initialization_order) if parameter_name == "processes": processes_block_names = [ "constraints_process_list", "loads_process_list", "list_other_processes", "json_output_process", "json_check_process", "check_analytic_results_process", "contact_process_list" ] if len( list_of_processes ) == 0: # Processes are given in the old format (or no processes are specified) deprecation_warning_issued = False from KratosMultiphysics.process_factory import KratosProcessFactory factory = KratosProcessFactory(self.model) for process_name in processes_block_names: if self.project_parameters.Has(process_name): if not deprecation_warning_issued: info_msg = "Using the old way to create the processes, this will be removed!\n" info_msg += "Refer to \"https://github.com/KratosMultiphysics/Kratos/wiki/Common-" info_msg += "Python-Interface-of-Applications-for-Users#analysisstage-usage\" " info_msg += "for a description of the new format" KratosMultiphysics.Logger.PrintWarning( "StructuralMechanicsAnalysis", info_msg) deprecation_warning_issued = True list_of_processes += factory.ConstructListOfProcesses( self.project_parameters[process_name]) else: # Processes are given in the new format for process_name in processes_block_names: if self.project_parameters.Has(process_name): raise Exception( "Mixing of process initialization is not allowed!") elif parameter_name == "output_processes": if self.project_parameters.Has("output_configuration"): info_msg = "Using the old way to create the gid-output, this will be removed!\n" info_msg += "Refer to \"https://github.com/KratosMultiphysics/Kratos/wiki/Common-" info_msg += "Python-Interface-of-Applications-for-Users#analysisstage-usage\" " info_msg += "for a description of the new format" KratosMultiphysics.Logger.PrintWarning( "StructuralMechanicsAnalysis", info_msg) gid_output = self._SetUpGiDOutput() list_of_processes += [ gid_output, ] else: raise NameError("wrong parameter name") return list_of_processes
def testVectorCellCenterAveragingProcess(self): self.__CreateModel() settings = Kratos.Parameters(r''' [ { "kratos_module" : "KratosMultiphysics.RANSApplication", "python_module" : "cpp_process_factory", "process_name" : "FindNodalNeighboursProcess", "Parameters" : { "model_part_name" : "test" } }, { "kratos_module" : "KratosMultiphysics.RANSApplication", "python_module" : "cpp_process_factory", "process_name" : "FindConditionParentProcess", "Parameters" : { "model_part_name" : "test.submodelpart_1" } }, { "kratos_module" : "KratosMultiphysics.RANSApplication", "python_module" : "cpp_process_factory", "process_name" : "VectorCellCenteredAveragingProcess", "Parameters" : { "echo_level" : 0, "model_part_name" : "test.submodelpart_1", "input_variable_name" : "VELOCITY", "output_variable_name" : "VELOCITY" } } ]''') check_values = [] for node in self.model_part.Nodes: velocity = node.GetSolutionStepValue(Kratos.VELOCITY) check_values.append( [float(velocity[0]), float(velocity[1]), float(velocity[2])]) for i in range(3): check_values[0][i] = check_values[5][i] / 3.0 check_values[1][ i] = check_values[5][i] / 6.0 + check_values[4][i] / 6.0 check_values[2][i] = check_values[4][i] / 3.0 factory = KratosProcessFactory(self.model) self.process_list = factory.ConstructListOfProcesses(settings) self.__ExecuteProcesses() for node, value in zip(self.model_part.Nodes, check_values): node_value = node.GetSolutionStepValue(Kratos.VELOCITY) for i in range(3): self.assertAlmostEqual(node_value[i], value[i], 9)
def _CreateProcesses(self, parameter_name, initialization_order): """Create a list of Processes""" list_of_processes = super(ParticleMechanicsAnalysis, self)._CreateProcesses( parameter_name, initialization_order) if parameter_name == "processes": processes_block_names = [ "constraints_process_list", "loads_process_list", "list_other_processes", "gravity" ] if len(list_of_processes ) == 0: # Processes are given in the old format info_msg = "Using the old way to create the processes, this will be removed!\n" info_msg += "Refer to \"https://github.com/KratosMultiphysics/Kratos/wiki/Common-" info_msg += "Python-Interface-of-Applications-for-Users#analysisstage-usage\" " info_msg += "for a description of the new format" KratosMultiphysics.Logger.PrintWarning( "ParticleMechanicsAnalysis", info_msg) from KratosMultiphysics.process_factory import KratosProcessFactory factory = KratosProcessFactory(self.model) for process_name in processes_block_names: if (self.project_parameters.Has(process_name) is True): list_of_processes += factory.ConstructListOfProcesses( self.project_parameters[process_name]) else: # Processes are given in the new format for process_name in processes_block_names: if (self.project_parameters.Has(process_name) is True): raise Exception( "Mixing of process initialization is not allowed!") elif parameter_name == "output_processes": if self.project_parameters.Has("grid_output_configuration" ) or self.project_parameters.Has( "body_output_configuration"): info_msg = "Using the old way to create the gid-output for grid, this will be removed!\n" info_msg += "Refer to \"https://github.com/KratosMultiphysics/Kratos/wiki/Common-" info_msg += "Python-Interface-of-Applications-for-Users#analysisstage-usage\" " info_msg += "for a description of the new format" KratosMultiphysics.Logger.PrintInfo( "ParticleMechanicsAnalysis", info_msg) if self.project_parameters.Has("grid_output_configuration"): grid_gid_output = self._SetUpGiDOutput("grid_output") list_of_processes += [ grid_gid_output, ] if self.project_parameters.Has("body_output_configuration"): mp_gid_output = self._SetUpGiDOutput("body_output") list_of_processes += [ mp_gid_output, ] else: raise NameError("wrong parameter name") return list_of_processes
def __TestMethod(self, settings): factory = KratosProcessFactory(self.current_model) self.process_list = factory.ConstructListOfProcesses(settings) InitializeProcesses(self) for step in range(0, 12, 2): self.model_part.CloneTimeStep(step) self.model_part.ProcessInfo[Kratos.STEP] = step InitializeModelPartVariables(self.model_part, False) ExecuteProcessFinalizeSolutionStep(self) for process in self.process_list: process.ExecuteFinalize()
def testApplyFlagProcess(self): self.__CreateModel() settings = Kratos.Parameters(r''' [ { "kratos_module" : "KratosMultiphysics.RANSApplication", "python_module" : "cpp_process_factory", "process_name" : "ApplyFlagProcess", "Parameters" : { "model_part_name" : "test.submodelpart_1", "echo_level" : 0, "flag_variable_name" : "STRUCTURE", "flag_variable_value" : true, "apply_to_model_part_conditions" : ["ALL_MODEL_PARTS"] } }, { "kratos_module" : "KratosMultiphysics.RANSApplication", "python_module" : "cpp_process_factory", "process_name" : "ApplyFlagProcess", "Parameters" : { "model_part_name" : "test.submodelpart_2", "echo_level" : 0, "flag_variable_name" : "INLET", "flag_variable_value" : true, "apply_to_model_part_conditions" : ["ALL_MODEL_PARTS"] } } ]''') factory = KratosProcessFactory(self.model) self.process_list = factory.ConstructListOfProcesses(settings) self.__ExecuteProcesses() check_values = [True, True, True, False, False, False] for node, value in zip(self.model_part.Nodes, check_values): self.assertEqual(node.Is(Kratos.STRUCTURE), value) check_values = [False, False, True, True, True, False] for node, value in zip(self.model_part.Nodes, check_values): self.assertEqual(node.Is(Kratos.INLET), value) check_values = [True, True, False, False, False, False] for condition, value in zip(self.model_part.Conditions, check_values): self.assertEqual(condition.Is(Kratos.STRUCTURE), value) check_values = [False, False, True, True, False, False] for condition, value in zip(self.model_part.Conditions, check_values): self.assertEqual(condition.Is(Kratos.INLET), value)
def testLogarithmicYPlusCalculationProcess(self): self.__CreateModel() settings = Kratos.Parameters(r''' [ { "kratos_module" : "KratosMultiphysics.RANSApplication", "python_module" : "cpp_process_factory", "process_name" : "LogarithmicYPlusCalculationProcess", "Parameters" : { "model_part_name" : "test", "echo_level" : 0, "step" : 0, "max_iterations" : 10, "tolerance" : 1e-6, "constants": { "von_karman" : 0.41, "beta" : 5.2 } } } ]''') # for node, distance in zip(self.model_part.Nodes, distance_value): # node.SetSolutionStepValue(Kratos.DISTANCE, 0, distance) factory = KratosProcessFactory(self.model) self.process_list = factory.ConstructListOfProcesses(settings) self.__ExecuteProcesses() beta = 5.2 von_karman = 0.41 for node in self.model_part.Nodes: y_plus = node.GetSolutionStepValue(KratosRANS.RANS_Y_PLUS) nu = node.GetSolutionStepValue(Kratos.KINEMATIC_VISCOSITY) y = node.GetSolutionStepValue(Kratos.DISTANCE) u = node.GetSolutionStepValue(Kratos.VELOCITY) if (y > 0.0): u_tau = y_plus * nu / y u_plus = math.sqrt(u[0] * u[0] + u[1] * u[1] + u[2] * u[2]) / u_tau if (y_plus > 11.06): self.assertAlmostEqual( u_plus, 1 / von_karman * math.log(y_plus) + beta, 9) print("Checked logarithmic region...") else: self.assertAlmostEqual(u_plus, y_plus, 9) print("Checked linear region...") else: self.assertAlmostEqual(y_plus, 0.0, 9)
def testApplyFlagProcess(self): settings = Kratos.Parameters(r''' [ { "kratos_module" : "KratosMultiphysics.RANSApplication", "python_module" : "cpp_process_factory", "process_name" : "ApplyFlagProcess", "Parameters" : { "model_part_name" : "FluidModelPart.Slip2D.Slip2D_walls", "echo_level" : 0, "flag_variable_name" : "STRUCTURE", "flag_variable_value" : true, "apply_to_model_part_conditions" : ["ALL_MODEL_PARTS"] } }, { "kratos_module" : "KratosMultiphysics.RANSApplication", "python_module" : "cpp_process_factory", "process_name" : "ApplyFlagProcess", "Parameters" : { "model_part_name" : "FluidModelPart.AutomaticInlet2D_inlet", "echo_level" : 0, "flag_variable_name" : "INLET", "flag_variable_value" : true, "apply_to_model_part_conditions" : ["ALL_MODEL_PARTS"] } } ]''') factory = KratosProcessFactory(self.model) self.process_list = factory.ConstructListOfProcesses(settings) self.__ExecuteProcesses() for node in self.model.GetModelPart( "FluidModelPart.AutomaticInlet2D_inlet").Nodes: self.assertEqual(node.Is(Kratos.INLET), True) for condition in self.model.GetModelPart( "FluidModelPart.AutomaticInlet2D_inlet").Conditions: self.assertEqual(condition.Is(Kratos.INLET), True) self.assertEqual(condition.Is(Kratos.STRUCTURE), False) for node in self.model.GetModelPart( "FluidModelPart.Slip2D.Slip2D_walls").Nodes: self.assertEqual(node.Is(Kratos.STRUCTURE), True) for condition in self.model.GetModelPart( "FluidModelPart.Slip2D.Slip2D_walls").Conditions: self.assertEqual(condition.Is(Kratos.STRUCTURE), True) self.assertEqual(condition.Is(Kratos.INLET), False)
def testScalarCellCenterAveragingProcess(self): self.__CreateModel() settings = Kratos.Parameters(r''' [ { "kratos_module" : "KratosMultiphysics.RANSApplication", "python_module" : "cpp_process_factory", "process_name" : "FindNodalNeighboursProcess", "Parameters" : { "model_part_name" : "test" } }, { "kratos_module" : "KratosMultiphysics.RANSApplication", "python_module" : "cpp_process_factory", "process_name" : "FindConditionParentProcess", "Parameters" : { "model_part_name" : "test.submodelpart_1" } }, { "kratos_module" : "KratosMultiphysics.RANSApplication", "python_module" : "cpp_process_factory", "process_name" : "ScalarCellCenteredAveragingProcess", "Parameters" : { "echo_level" : 0, "model_part_name" : "test.submodelpart_1", "input_variable_name" : "DENSITY", "output_variable_name" : "DENSITY" } } ]''') check_values = [] for node in self.model_part.Nodes: check_values.append(node.GetSolutionStepValue(Kratos.DENSITY)) factory = KratosProcessFactory(self.model) self.process_list = factory.ConstructListOfProcesses(settings) self.__ExecuteProcesses() check_values[0] = check_values[5] / 3.0 check_values[1] = check_values[5] / 6.0 + check_values[4] / 6.0 check_values[2] = check_values[4] / 3.0 for node, value in zip(self.model_part.Nodes, check_values): self.assertAlmostEqual(node.GetSolutionStepValue(Kratos.DENSITY), value, 9)
def _CreateProcesses(self, parameter_name, initialization_order): """Create a list of Processes This method is TEMPORARY to not break existing code It will be removed in the future """ list_of_processes = super(FluidDynamicsAnalysis, self)._CreateProcesses( parameter_name, initialization_order) # The list of processes will contain a list with each individual process already constructed (boundary conditions, initial conditions and gravity) # Note 1: gravity is constructed first. Outlet process might need its information. # Note 2: initial conditions are constructed before BCs. Otherwise, they may overwrite the BCs information. if parameter_name == "processes": processes_block_names = [ "gravity", "initial_conditions_process_list", "boundary_conditions_process_list", "auxiliar_process_list" ] if len(list_of_processes ) == 0: # Processes are given in the old format info_msg = "Using the old way to create the processes, this will be removed!\n" info_msg += "Refer to \"https://github.com/KratosMultiphysics/Kratos/wiki/Common-" info_msg += "Python-Interface-of-Applications-for-Users#analysisstage-usage\" " info_msg += "for a description of the new format" Kratos.Logger.PrintWarning("FluidDynamicsAnalysis", info_msg) factory = KratosProcessFactory(self.model) for process_name in processes_block_names: if (self.project_parameters.Has(process_name) is True): list_of_processes += factory.ConstructListOfProcesses( self.project_parameters[process_name]) else: # Processes are given in the new format for process_name in processes_block_names: if (self.project_parameters.Has(process_name) is True): raise Exception( "Mixing of process initialization is not alowed!") elif parameter_name == "output_processes": if self.project_parameters.Has("output_configuration"): info_msg = "Using the old way to create the gid-output, this will be removed!\n" info_msg += "Refer to \"https://github.com/KratosMultiphysics/Kratos/wiki/Common-" info_msg += "Python-Interface-of-Applications-for-Users#analysisstage-usage\" " info_msg += "for a description of the new format" Kratos.Logger.PrintWarning("FluidDynamicsAnalysis", info_msg) gid_output = self._SetUpGiDOutput() list_of_processes += [ gid_output, ] else: raise NameError("wrong parameter name") return list_of_processes
def _CreateProcesses(self, parameter_name, initialization_order): """Create a list of Processes This method is TEMPORARY to not break existing code It will be removed in the future """ list_of_processes = super(AdjointFluidAnalysis, self)._CreateProcesses( parameter_name, initialization_order) # The list of processes will contain a list with each individual process already constructed (boundary conditions, initial conditions and gravity) # Note 1: gravity is constructed first. Outlet process might need its information. # Note 2: initial conditions are constructed before BCs. Otherwise, they may overwrite the BCs information. if parameter_name == "processes": processes_block_names = [ "gravity", "initial_conditions_process_list", "boundary_conditions_process_list", "auxiliar_process_list" ] if len(list_of_processes ) == 0: # Processes are given in the old format Kratos.Logger.PrintWarning( self.__class__.__name__, "Using the old way to create the processes, this will be removed!" ) factory = KratosProcessFactory(self.model) for process_name in processes_block_names: if (self.project_parameters.Has(process_name) is True): list_of_processes += factory.ConstructListOfProcesses( self.project_parameters[process_name]) else: # Processes are given in the new format for process_name in processes_block_names: if (self.project_parameters.Has(process_name) is True): raise Exception( "Mixing of process initialization is not alowed!") elif parameter_name == "output_processes": if self.project_parameters.Has("output_configuration"): Kratos.Logger.PrintWarning( self.__class__.__name__, "Using the old way to create the gid-output, this will be removed!" ) gid_output = self._SetUpGiDOutput() list_of_processes += [ gid_output, ] else: raise NameError("wrong parameter name") return list_of_processes
def Initialize(self): self.PrepareSolvingStrategy() factory = KratosProcessFactory(self.model) self.auxiliar_process_list = factory.ConstructListOfProcesses( self.settings["auxiliar_process_list"]) for process in self.auxiliar_process_list: self.GetTurbulenceSolvingProcess().AddAuxiliaryProcess(process) process.ExecuteInitialize() self.GetTurbulenceSolvingProcess().ExecuteInitialize() for strategy in self.strategies_list: strategy.Initialize() Kratos.Logger.PrintInfo(self.__class__.__name__, "Initialization successfull.")
def testCheckScalarBoundsProcess(self): settings = Kratos.Parameters(r''' [ { "kratos_module" : "KratosMultiphysics.RANSApplication", "python_module" : "cpp_process_factory", "process_name" : "CheckScalarBoundsProcess", "Parameters" : { "model_part_name" : "FluidModelPart", "variable_name" : "DENSITY" } } ]''') factory = KratosProcessFactory(self.model) self.process_list = factory.ConstructListOfProcesses(settings) self.__ExecuteProcesses()
def testWallDistanceCalculationProcess(self): settings = Kratos.Parameters(r''' [ { "kratos_module" : "KratosMultiphysics.RANSApplication", "python_module" : "cpp_process_factory", "process_name" : "ApplyFlagProcess", "Parameters" : { "model_part_name" : "test.Slip2D.Slip2D_walls", "echo_level" : 0, "flag_variable_name" : "STRUCTURE", "flag_variable_value" : true, "apply_to_model_part_conditions" : ["ALL_MODEL_PARTS"] } }, { "kratos_module" : "KratosMultiphysics.RANSApplication", "python_module" : "cpp_process_factory", "process_name" : "WallDistanceCalculationProcess", "Parameters" : { "model_part_name" : "test", "max_iterations" : 10, "echo_level" : 0, "wall_flag_variable_name" : "STRUCTURE", "wall_flag_variable_value" : true, "re_calculate_at_each_time_step" : false, "correct_distances_using_neighbors": true, "linear_solver_settings" : { "solver_type" : "amgcl" } } } ]''') test_variables = ["DISTANCE"] test_model_part_name = "test" test_file_name = "wall_distance_calculation_test_output" CustomProcessTest.__AddJsonCheckProcess(settings, test_variables, test_model_part_name, test_file_name) # CustomProcessTest.__AddJsonOutputProcess(settings, test_variables, test_model_part_name, test_file_name) factory = KratosProcessFactory(self.model) self.process_list = factory.ConstructListOfProcesses(settings) self.__ExecuteProcesses()
def testWallDistanceCalculationProcess(self): self.__CreateModel( variable_list=[Kratos.DISTANCE, Kratos.FLAG_VARIABLE]) settings = Kratos.Parameters(r''' [ { "kratos_module" : "KratosMultiphysics.RANSApplication", "python_module" : "cpp_process_factory", "process_name" : "ApplyFlagProcess", "Parameters" : { "model_part_name" : "test.submodelpart_1", "echo_level" : 0, "flag_variable_name" : "STRUCTURE", "flag_variable_value" : true, "apply_to_model_part_conditions" : ["ALL_MODEL_PARTS"] } }, { "kratos_module" : "KratosMultiphysics.RANSApplication", "python_module" : "cpp_process_factory", "process_name" : "WallDistanceCalculationProcess", "Parameters" : { "model_part_name" : "test", "max_iterations" : 1000, "echo_level" : 0, "wall_flag_variable_name" : "STRUCTURE", "wall_flag_variable_value" : true, "linear_solver_settings" : { "solver_type" : "amgcl" } } } ]''') check_values = [0.0, 0.0, 0.0, 1.0, 1.0, 1.0] factory = KratosProcessFactory(self.model) self.process_list = factory.ConstructListOfProcesses(settings) self.__ExecuteProcesses() for node, value in zip(self.model_part.Nodes, check_values): node_value = node.GetSolutionStepValue(Kratos.DISTANCE) self.assertAlmostEqual(node_value, value, 9)
def _CreateProcesses(self, parameter_name, initialization_order): """Create a list of processes Format: "processes" : { initial_processes : [ { proces_specific_params }, { proces_specific_params } ], boundary_processes : [ { proces_specific_params }, { proces_specific_params } ] } The order of intialization can be specified by setting it in "initialization_order" if e.g. the "boundary_processes" should be constructed before the "initial_processes", then initialization_order should be a list containing ["boundary_processes", "initial_processes"] see the functions _GetOrderOfProcessesInitialization and _GetOrderOfOutputProcessesInitialization """ list_of_processes = [] factory = KratosProcessFactory(self.model) if self.project_parameters.Has(parameter_name): processes_params = self.project_parameters[parameter_name] # first initialize the processes that depend on the order for processes_names in initialization_order: if processes_params.Has(processes_names): list_of_processes += factory.ConstructListOfProcesses( processes_params[processes_names]) # then initialize the processes that don't depend on the order for name, value in processes_params.items(): if not name in initialization_order: list_of_processes += factory.ConstructListOfProcesses( value ) # Does this work? or should it be processes[name] return list_of_processes
def testLogarithmicYPlusVelocitySensitivitiesProcessFlow(self): self.__CreateModel() settings = Kratos.Parameters(r''' [ { "kratos_module" : "KratosMultiphysics.RANSApplication", "python_module" : "cpp_process_factory", "process_name" : "LogarithmicYPlusCalculationProcess", "Parameters" : { "model_part_name" : "test", "echo_level" : 0, "max_iterations" : 10, "tolerance" : 1e-6, "constants": { "von_karman" : 0.41, "beta" : 5.2 } } }, { "kratos_module" : "KratosMultiphysics.RANSApplication", "python_module" : "cpp_process_factory", "process_name" : "LogarithmicYPlusVelocitySensitivitiesProcess", "Parameters" : { "model_part_name" : "test", "echo_level" : 0, "constants": { "von_karman" : 0.41, "beta" : 5.2 } } } ]''') factory = KratosProcessFactory(self.model) self.process_list = factory.ConstructListOfProcesses(settings) self.__ExecuteProcesses()
def testClipScalarVariableProcess(self): settings = Kratos.Parameters(r''' [ { "kratos_module" : "KratosMultiphysics.RANSApplication", "python_module" : "cpp_process_factory", "process_name" : "ClipScalarVariableProcess", "Parameters" : { "model_part_name" : "FluidModelPart", "variable_name" : "DENSITY", "min_value" : 20.0, "max_value" : 60.0 } } ]''') factory = KratosProcessFactory(self.model) self.process_list = factory.ConstructListOfProcesses(settings) self.__ExecuteProcesses() for node in self.model_part.Nodes: density = node.GetSolutionStepValue(Kratos.DENSITY) self.assertEqual(density >= 20.0, True) self.assertEqual(density <= 60.0, True)
def testNutKOmegaSSTUpdateProcess(self): settings = Kratos.Parameters(r''' [ { "kratos_module" : "KratosMultiphysics.RANSApplication", "python_module" : "cpp_process_factory", "process_name" : "NutKOmegaSSTUpdateProcess", "Parameters" : { "model_part_name" : "FluidModelPart" } } ]''') test_variables = ["TURBULENT_VISCOSITY", "VISCOSITY"] test_model_part_name = "FluidModelPart.AutomaticInlet2D_inlet" test_file_name = "nut_k_omega_sst_test_output" CustomProcessTest.__AddJsonCheckProcess(settings, test_variables, test_model_part_name, test_file_name) # CustomProcessTest.__AddJsonOutputProcess(settings, test_variables, test_model_part_name, test_file_name) factory = KratosProcessFactory(self.model) self.process_list = factory.ConstructListOfProcesses(settings) self.__ExecuteProcesses()
def _RunProcessTest(self, settings): with UnitTest.WorkFolderScope(".", __file__): factory = KratosProcessFactory(self.model) self.process_list = factory.ConstructListOfProcesses(settings) self._ExecuteProcesses()
def RunTemporalStatisticsTest(self, norm_type, container_name): settings = TemporalMaxMethodHelperClass.__GetDefaultParameters( norm_type, container_name) input_method = TemporalMaxMethodHelperClass.GetInputMethod( container_name) output_method = TemporalMaxMethodHelperClass.GetOutputMethod( container_name) container = self.GetContainer(container_name) factory = KratosProcessFactory(self.GetModel()) self.process_list = factory.ConstructListOfProcesses(settings) InitializeProcesses(self) scalar_list, vec_3d_list, vec_list, mat_list = InitializeContainerArrays( container) step_list = [] for step in range(0, 12, 2): self.model_part.CloneTimeStep(step) InitializeModelPartVariables(self.GetModelPart()) ExecuteProcessFinalizeSolutionStep(self) step_list.append(step) for index, item in enumerate(container): current_scalar = input_method(item, Kratos.PRESSURE) current_vector_3d = input_method(item, Kratos.VELOCITY) current_vector = input_method(item, Kratos.LOAD_MESHES) current_matrix = input_method( item, Kratos.GREEN_LAGRANGE_STRAIN_TENSOR) if (step >= 0): scalar_list[index].append(current_scalar) vec_3d_list[index].append(current_vector_3d) vec_list[index].append(current_vector) mat_list[index].append(current_matrix) analytical_method_scalar = TemporalMaxMethodHelperClass.__AnalyticalMethod( norm_type, Kratos.PRESSURE, scalar_list[index], step_list) analytical_method_vec_3d = TemporalMaxMethodHelperClass.__AnalyticalMethod( norm_type, Kratos.VELOCITY, vec_3d_list[index], step_list) analytical_method_vec = TemporalMaxMethodHelperClass.__AnalyticalMethod( norm_type, Kratos.LOAD_MESHES, vec_list[index], step_list) analytical_method_mat = TemporalMaxMethodHelperClass.__AnalyticalMethod( norm_type, Kratos.GREEN_LAGRANGE_STRAIN_TENSOR, mat_list[index], step_list) mean_method_scalar = output_method(item, KratosStats.SCALAR_NORM) mean_method_vec_3d = output_method(item, KratosStats.VECTOR_3D_NORM) mean_method_vec = output_method(item, Kratos.DENSITY) mean_method_mat = output_method(item, Kratos.VISCOSITY) variance_method_scalar = output_method(item, Kratos.YIELD_STRESS) variance_method_vec_3d = output_method(item, Kratos.CUTTED_AREA) variance_method_vec = output_method(item, Kratos.NET_INPUT_MATERIAL) variance_method_mat = output_method(item, Kratos.WET_VOLUME) CheckValues(self, analytical_method_scalar[0], mean_method_scalar, 8) CheckValues(self, analytical_method_vec_3d[0], mean_method_vec_3d, 8) CheckValues(self, analytical_method_vec[0], mean_method_vec, 8) CheckValues(self, analytical_method_mat[0], mean_method_mat, 8) CheckValues(self, analytical_method_scalar[1], variance_method_scalar, 8) CheckValues(self, analytical_method_vec_3d[1], variance_method_vec_3d, 8) CheckValues(self, analytical_method_vec[1], variance_method_vec, 8) CheckValues(self, analytical_method_mat[1], variance_method_mat, 8)