def _GetAdjointParameters(self): with open(self.response_settings["adjoint_settings"].GetString(), 'r') as parameter_file: adjoint_parameters = Parameters(parameter_file.read()) if self.response_settings["transfer_response_parameters"].GetBool(): # sensitivity settings if adjoint_parameters["solver_settings"].Has( "sensitivity_settings"): Logger.PrintWarning( self._GetLabel(), "Adjoint settings already have 'sensitivity_settings' - Will be overwritten!" ) adjoint_parameters["solver_settings"].RemoveValue( "sensitivity_settings") adjoint_parameters["solver_settings"].AddValue( "sensitivity_settings", self.response_settings["sensitivity_settings"]) # response settings if adjoint_parameters["solver_settings"].Has( "response_function_settings"): Logger.PrintWarning( self._GetLabel(), "Adjoint settings already have 'response_function_settings' - Will be overwritten!" ) adjoint_parameters["solver_settings"].RemoveValue( "response_function_settings") adjoint_parameters["solver_settings"].AddValue( "response_function_settings", self.response_settings) return adjoint_parameters
def RenumberNodesIdsToAvoidRepeating(fluid_model_part, dem_model_part, rigid_faces_model_part): max_fluid_id = FindMaxNodeId(fluid_model_part) must_renumber = True in (node.Id < max_fluid_id for node in list(dem_model_part.Nodes) + list(rigid_faces_model_part.Nodes)) if must_renumber: Logger.PrintWarning( "SwimmingDEM", "WARNING!, the DEM model part and the fluid model part have some ID values in common. Renumbering..." ) for node in dem_model_part.Nodes: node.Id += max_fluid_id for node in rigid_faces_model_part.Nodes: node.Id += max_fluid_id Logger.PrintWarning( "SwimmingDEM", "The DEM model part and the fem-DEM model parts Ids have been renumbered" )
def ImportApplication(application, application_name, application_folder, caller, mod_path=None): KratosGlobals = KratosMultiphysics.KratosGlobals Kernel = KratosGlobals.Kernel applications_root = KratosGlobals.ApplicationsRoot Logger.PrintInfo("", "Importing " + application_name) # Add python scrips folder to path application_path = os.path.join(applications_root, application_folder) python_path = os.path.join(application_path, 'python_scripts') sys.path.append(python_path) # Add constitutive laws python scrips folder to path constitutive_laws_path = os.path.join(python_path, 'constitutive_laws') sys.path.append(constitutive_laws_path) warn_msg = '\nThe python-import-mechanism used for application "' + application_name warn_msg += '" is DEPRECATED!\n' warn_msg += 'Please check the following website for instuctions on how to update it:\n' warn_msg += 'https://github.com/KratosMultiphysics/Kratos/wiki/Applications-as-python-modules\n' warn_msg += 'The old mechanism will be removed on 01.10.2019!\n' Logger.PrintWarning('\n\x1b[1;31mDEPRECATION-WARNING\x1b[0m', warn_msg) # adding the scripts in "APP_NAME/python_scripts" such that they are treated as a regular python-module if mod_path is not None: # optional for backwards compatibility mod_path.append(python_path) # Add application to kernel Kernel.ImportApplication(application)
def _CheckParameters(self, parameters): if not parameters["solver_settings"].Has( "reform_dofs_at_each_step") or not parameters[ "solver_settings"]["reform_dofs_at_each_step"].GetBool(): if not parameters["solver_settings"].Has( "reform_dofs_at_each_step"): parameters["solver_settings"].AddEmptyValue( "reform_dofs_at_each_step") parameters["solver_settings"]["reform_dofs_at_each_step"].SetBool( True) wrn_msg = 'This solver requires the setting reform the dofs at each step in optimization.' wrn_msg += 'The solver setting has been set to True' Logger.PrintWarning(self._GetLabel(), wrn_msg) for subproc_keys, subproc_values in parameters["processes"].items(): for process in subproc_values: if "wake" in process["python_module"].GetString(): if not process["Parameters"].Has( "compute_wake_at_each_step" ) or not process["Parameters"][ "compute_wake_at_each_step"].GetBool(): if not process["Parameters"].Has( "compute_wake_at_each_step"): process["Parameters"].AddEmptyValue( "compute_wake_at_each_step") process["Parameters"]["compute_wake_at_each_step"].SetBool( True) return parameters
def Initialize(self): if self.response_settings["model_import_settings"][ "input_type"].GetString() == "mdpa": file_name = self.response_settings["model_import_settings"][ "input_filename"].GetString() model_part_io = KM.ModelPartIO(file_name) model_part_io.ReadModelPart(self.model_part) else: self.model_part = self.model.GetModelPart(self._model_part_name) only = self.response_settings["only"].GetString() if only != "": only_part = self.model.GetModelPart(only) if only_part.NumberOfConditions() == 0: _AddConditionsFromParent(self.model_part, only_part) Logger.PrintWarning( "FaceAngleResponse", "Automatically added {} conditions to model_part '{}'.". format(only_part.NumberOfConditions(), only_part.Name)) else: only_part = self.model_part if only_part.NumberOfConditions() == 0: raise RuntimeError( "The model_part '{}' does not have any surface conditions!". format(only_part.Name)) self.response_function_utility = KSO.FaceAngleResponseFunctionUtility( only_part, self.response_settings) self.response_function_utility.Initialize()
def ApplySimilarityTransformations(fluid_model_part, transformation_type, mod_over_real): if transformation_type == 0: return elif transformation_type == 1: Logger.PrintWarning( "SwimmingDEM", '***\n\nWARNING!, applying similarity transformations to the problem fluid variables' ) Logger.PrintWarning("SwimmingDEM", 'The particles diameters quotient is\n') Logger.PrintWarning("SwimmingDEM", 'D_model / D_real =', mod_over_real) Logger.PrintWarning("SwimmingDEM", ) if transformation_type == 1: # Tsuji 2013, (Preserves Archimedes and Reynolds numbers) Logger.PrintWarning( 'The fluid variables to be modified are\n\nDENSITY\nVISCOSITY\n\n***' ) fluid_density_factor = mod_over_real fluid_viscosity_factor = mod_over_real * mod_over_real MultiplyNodalVariableByFactor(fluid_model_part, Kratos.DENSITY, fluid_density_factor) MultiplyNodalVariableByFactor(fluid_model_part, Kratos.VISCOSITY, fluid_viscosity_factor) else: Logger.PrintWarning( "SwimmingDEM", ('The entered value similarity_transformation_type = ', transformation_type, 'is not currently supported'))
def __init__(self, identifier, response_settings, model): self.identifier = identifier with open(response_settings["primal_settings"].GetString()) as parameters_file: ProjectParametersPrimal = Parameters(parameters_file.read()) eigen_solver_settings = ProjectParametersPrimal["solver_settings"]["eigensolver_settings"] max_required_eigenfrequency = int(max(response_settings["traced_eigenfrequencies"].GetVector())) if max_required_eigenfrequency is not eigen_solver_settings["number_of_eigenvalues"].GetInt(): Logger.PrintWarning("EigenFrequencyResponse", "Specified number of eigenvalues in the primal analysis and the max required eigenvalue according the response settings do not match!!!") Logger.PrintWarning("EigenFrequencyResponse", "Primal parameters were adjusted accordingly!\n") eigen_solver_settings["number_of_eigenvalues"].SetInt(max_required_eigenfrequency) if not eigen_solver_settings.Has("normalize_eigenvectors"): eigen_solver_settings.AddEmptyValue("normalize_eigenvectors") eigen_solver_settings["normalize_eigenvectors"].SetBool(True) Logger.PrintWarning("EigenFrequencyResponse", "Eigenfrequency response function requires mass normalization of eigenvectors!") Logger.PrintWarning("EigenFrequencyResponse", "Primal parameters were adjusted accordingly!\n") if not eigen_solver_settings["normalize_eigenvectors"].GetBool(): eigen_solver_settings["normalize_eigenvectors"].SetBool(True) Logger.PrintWarning("EigenFrequencyResponse", "Eigenfrequency response function requires mass normalization of eigenvectors!") Logger.PrintWarning("EigenFrequencyResponse", "Primal parameters were adjusted accordingly!\n") self.primal_model_part = _GetModelPart(model, ProjectParametersPrimal["solver_settings"]) self.primal_analysis = StructuralMechanicsAnalysis(model, ProjectParametersPrimal) self.primal_model_part.AddNodalSolutionStepVariable(KratosMultiphysics.SHAPE_SENSITIVITY) self.response_function_utility = StructuralMechanicsApplication.EigenfrequencyResponseFunctionUtility(self.primal_model_part, response_settings)
def _GetAdjointParameters(self): adjoint_settings = self.response_settings[ "adjoint_settings"].GetString() if adjoint_settings == "auto": Logger.PrintInfo( self._GetLabel(), "Automatic set up adjoint parameters for response:", self.identifier) if not self.primal_data_transfer_with_python: raise Exception( "Auto setup of adjoint parameters does only support primal data transfer with python." ) with open(self.response_settings["primal_settings"].GetString(), 'r') as parameter_file: primal_parameters = Parameters(parameter_file.read()) # check that HDF5 process is not there if primal_parameters["processes"].Has("list_other_processes"): for i in range( 0, primal_parameters["processes"] ["list_other_processes"].size()): process = primal_parameters["processes"][ "list_other_processes"][i] raise Exception( "Auto setup of adjoint parameters does not support {} in list_other_processes" .format(process["python_module"].GetString())) # clone primal settings as base for adjoint adjoint_parameters = primal_parameters.Clone() # analysis settings solver_settings = adjoint_parameters["solver_settings"] primal_solver_type = solver_settings["solver_type"].GetString() if primal_solver_type != "static": raise Exception( "Auto setup of adjoint parameters does not support {} solver_type. Only available for 'static'" .format(primal_solver_type)) solver_settings["solver_type"].SetString("adjoint_" + primal_solver_type) if not solver_settings.Has("compute_reactions"): solver_settings.AddEmptyValue("compute_reactions") solver_settings["compute_reactions"].SetBool(False) if not solver_settings.Has("move_mesh_flag"): solver_settings.AddEmptyValue("move_mesh_flag") solver_settings["move_mesh_flag"].SetBool(False) if solver_settings.Has("scheme_settings"): depr_msg = '\nDEPRECATION-WARNING: "scheme_settings" is deprecated, please remove it from your json parameters.\n' Logger.PrintWarning(__name__, depr_msg) solver_settings.RemoveValue("scheme_settings") if solver_settings["model_import_settings"][ "input_type"].GetString() == "use_input_model_part": solver_settings["model_import_settings"][ "input_type"].SetString("mdpa") if solver_settings["model_import_settings"].Has( "input_filename"): file_name = solver_settings["model_import_settings"][ "input_filename"].GetString() else: Logger.PrintWarning( self._GetLabel(), "Automatic adjoint settings creator assumes the model_part_name as input_filename." ) solver_settings["model_import_settings"].AddEmptyValue( "input_filename") file_name = solver_settings["model_part_name"].GetString() solver_settings["model_import_settings"][ "input_filename"].SetString(file_name) # Dirichlet conditions: change variables for i in range( 0, primal_parameters["processes"] ["constraints_process_list"].size()): process = adjoint_parameters["processes"][ "constraints_process_list"][i] variable_name = process["Parameters"][ "variable_name"].GetString() process["Parameters"]["variable_name"].SetString("ADJOINT_" + variable_name) # Neumann conditions - do not modify to read the same load values as in primal: # Output process: # TODO how to add the output process? How find out about the variables? if adjoint_parameters.Has("output_processes"): Logger.PrintInfo( self._GetLabel(), "Output process is removed for adjoint analysis. To enable it define adjoint_parameters yourself." ) adjoint_parameters.RemoveValue("output_processes") # sensitivity settings adjoint_parameters["solver_settings"].AddValue( "sensitivity_settings", self.response_settings["sensitivity_settings"]) # response settings adjoint_parameters["solver_settings"].AddValue( "response_function_settings", self.response_settings) else: # adjoint parameters file is explicitely given - do not change it. with open(self.response_settings["adjoint_settings"].GetString(), 'r') as parameter_file: adjoint_parameters = Parameters(parameter_file.read()) return adjoint_parameters
# Import KratosUnittest import KratosMultiphysics.KratosUnittest as UnitTest import BackwardCouplingTestFactory as BackwardCouplingTF # Importing test factories if possible try: import InterpolationTestFactory as InterpolationTF interpolation_imports_available = True except ImportError: interpolation_imports_available = False try: import CandelierTestFactory as CandelierTF candelier_imports_available = True except ImportError: candelier_imports_available = False Logger.PrintWarning("SwimmingDEMTests", "Failed to import some of the modules necessary for the Candelier tests.") try: import FluidDEMTestFactory as FDEMTF fluid_DEM_coupling_imports_available = True except ImportError: fluid_DEM_coupling_imports_available = False try: import AnalyticTestFactory as AnalyticTF analytic_imports_available = True except ImportError: analytic_imports_available = False class interpolation_test_linear(InterpolationTF.TestFactory): file_name = "interpolation_tests/cube" file_parameters = "interpolation_tests/ProjectParametersCubeLinear.json"
def IssueDeprecationWarning(label, *message): from KratosMultiphysics import Logger Logger.PrintWarning('DEPRECATION-Warning; ' + label, ' '.join(map(str, message)))