def __init__(self, model, settings): """The constructor of the PythonSolver-Object. It is intended to be called from the constructor of deriving classes: super(DerivedSolver, self).__init__(settings) Keyword arguments: self -- It signifies an instance of a class. model -- The Model to be used settings -- The solver settings used """ if not isinstance(model, KratosMultiphysics.Model): raise Exception( "Input is expected to be provided as a Kratos Model object") if not isinstance(settings, KratosMultiphysics.Parameters): raise Exception( "Input is expected to be provided as a Kratos Parameters object" ) self.model = model self.settings = settings # TODO remove the check once the derived solvers implement this if hasattr(self, '_validate_settings_in_baseclass'): self.ValidateSettings() else: from KratosMultiphysics.kratos_utilities import IssueDeprecationWarning IssueDeprecationWarning( 'PythonSolver', 'the settings are not validated in the baseclass for solver "%s", please implement it' % (self.__class__.__name__)) self.echo_level = self.settings["echo_level"].GetInt()
def __init__(self, model, custom_settings): if custom_settings.Has("calculate_mesh_velocities"): from KratosMultiphysics.kratos_utilities import IssueDeprecationWarning warn_msg = 'Yor input-settings contain "calculate_mesh_velocities". This was removed from the solver and moved to MeshMovingApplication.MeshVelocityCalculationPlease update your code' IssueDeprecationWarning("MeshSolverBase", warn_msg) custom_settings.RemoveValue("calculate_mesh_velocities") self._validate_settings_in_baseclass=True # To be removed eventually super(MeshSolverBase,self).__init__(model, custom_settings) # Either retrieve the model part from the model or create a new one model_part_name = self.settings["model_part_name"].GetString() if model_part_name == "": raise Exception('Please provide the model part name as the "model_part_name" (string) parameter!') if self.model.HasModelPart(model_part_name): self.mesh_model_part = self.model.GetModelPart(model_part_name) else: self.mesh_model_part = model.CreateModelPart(model_part_name) domain_size = self.settings["domain_size"].GetInt() if domain_size == -1: raise Exception('Please provide the domain size as the "domain_size" (int) parameter!') self.mesh_model_part.ProcessInfo.SetValue(KratosMultiphysics.DOMAIN_SIZE, domain_size) KratosMultiphysics.Logger.PrintInfo("::[MeshSolverBase]:: Construction finished")
def GetRegisteredMPIMapperNames(*args): IssueDeprecationWarning( "MappingApplication", 'GetRegisteredMPIMapperNames is deprecated, please use "MappingApplication.MPIExtension.MPIMapperFactory.GetRegisteredMapperNames" instead' ) from KratosMultiphysics.MappingApplication.MPIExtension import MPIMapperFactory return MPIMapperFactory.GetRegisteredMapperNames(*args)
def validate_and_transfer_matching_settings(self, origin_settings, destination_settings): IssueDeprecationWarning('PythonSolver', '"validate_and_transfer_matching_settings" is deprecated, please use the functionalities provided by "GetDefaultSettings"') """Transfer matching settings from origin to destination. If a name in origin matches a name in destination, then the setting is validated against the destination. The typical use is for validating and extracting settings in derived classes: class A: def __init__(self, model_part, a_settings): default_a_settings = Parameters('''{ ... }''') a_settings.ValidateAndAssignDefaults(default_a_settings) class B(A): def __init__(self, model_part, custom_settings): b_settings = Parameters('''{ ... }''') # Here the settings contain default values. self.validate_and_transfer_matching_settings(custom_settings, b_settings) super().__init__(model_part, custom_settings) """ for name, dest_value in destination_settings.items(): if origin_settings.Has(name): # Validate and transfer value. orig_value = origin_settings[name] if dest_value.IsDouble() and orig_value.IsDouble(): destination_settings[name].SetDouble(origin_settings[name].GetDouble()) elif dest_value.IsInt() and orig_value.IsInt(): destination_settings[name].SetInt(origin_settings[name].GetInt()) elif dest_value.IsBool() and orig_value.IsBool(): destination_settings[name].SetBool(origin_settings[name].GetBool()) elif dest_value.IsString() and orig_value.IsString(): destination_settings[name].SetString(origin_settings[name].GetString()) elif dest_value.IsArray() and orig_value.IsArray(): if dest_value.size() != orig_value.size(): raise Exception('len("' + name + '") != ' + str(dest_value.size())) for i in range(dest_value.size()): if dest_value[i].IsDouble() and orig_value[i].IsDouble(): dest_value[i].SetDouble(orig_value[i].GetDouble()) elif dest_value[i].IsInt() and orig_value[i].IsInt(): dest_value[i].SetInt(orig_value[i].GetInt()) elif dest_value[i].IsBool() and orig_value[i].IsBool(): dest_value[i].SetBool(orig_value[i].GetBool()) elif dest_value[i].IsString() and orig_value[i].IsString(): dest_value[i].SetString(orig_value[i].GetString()) elif dest_value[i].IsSubParameter() and orig_value[i].IsSubParameter(): self.validate_and_transfer_matching_settings(orig_value[i], dest_value[i]) if len(orig_value[i].items()) != 0: raise Exception('Json settings not found in default settings: ' + orig_value[i].PrettyPrintJsonString()) else: raise Exception('Unsupported parameter type.') elif dest_value.IsSubParameter() and orig_value.IsSubParameter(): self.validate_and_transfer_matching_settings(orig_value, dest_value) if len(orig_value.items()) != 0: raise Exception('Json settings not found in default settings: ' + orig_value.PrettyPrintJsonString()) else: raise Exception('Unsupported parameter type.') origin_settings.RemoveValue(name)
def print_warning_on_rank_zero(self, *args): IssueDeprecationWarning( 'PythonSolver', '"print_warning_on_rank_zero" is deprecated, please use the Logger directly' ) # This function will be overridden in the trilinos-solvers KratosMultiphysics.Logger.PrintWarning(" ".join(map(str, args)))
def HasMPIMapper(*args): IssueDeprecationWarning( "MappingApplication", 'HasMPIMapper is deprecated, please use "MappingApplication.MPIExtension.MPIMapperFactory.HasMapper" instead' ) from KratosMultiphysics.MappingApplication.MPIExtension import MPIMapperFactory return MPIMapperFactory.HasMapper(*args)
def Solve(self): warning_msg = 'Using "Solve" is deprecated and will be removed in the future!\n' warning_msg += 'Use the separate calls to "Initialize", "InitializeSolutionStep", "Predict", ' warning_msg += '"SolveSolutionStep" and "FinalizeSolutionStep"' IssueDeprecationWarning('PythonSolver', warning_msg) self.Initialize() self.InitializeSolutionStep() self.Predict() self.SolveSolutionStep() self.FinalizeSolutionStep()
def Factory(settings, Model): if not isinstance(settings, KM.Parameters): raise Exception("Expected input shall be a Parameters object, encapsulating a json string") model_part = Model[settings["Parameters"]["model_part_name"].GetString()] output_name = settings["Parameters"]["output_name"].GetString() postprocess_parameters = settings["Parameters"]["postprocess_parameters"] IssueDeprecationWarning("GiDOutputProcessMPI", "Attempting to create deprecated process \"GiDOutputProcessMPI\",", "please use \"DistributedGiDOutputProcess\" in module KratosMultiphysics.mpi instead.") return DistributedGiDOutputProcess(model_part, output_name, postprocess_parameters)
def __init__(self, main_model_part, custom_settings): if custom_settings.Has("linear_solver_settings"): IssueDeprecationWarning( 'EigenSolver', '"linear_solver_settings" was specified which is not used in the EigenSolver. Use "eigensolver_settings"!' ) custom_settings.RemoveValue("linear_solver_settings") # Construct the base solver. super().__init__(main_model_part, custom_settings) KratosMultiphysics.Logger.PrintInfo("::[EigenSolver]:: ", "Construction finished")
def __CheckIfSolveSolutionStepReturnsAValue(self, is_converged): """In case the solver does not return the state of convergence (same as the SolvingStrategy does) then issue ONCE a deprecation-warning """ if is_converged is None: if not hasattr(self, '_map_ret_val_depr_warnings'): self._map_ret_val_depr_warnings = [] solver_class_name = self._GetSolver().__class__.__name__ # used to only print the deprecation-warning once if not solver_class_name in self._map_ret_val_depr_warnings: self._map_ret_val_depr_warnings.append(solver_class_name) warn_msg = 'Solver "{}" does not return '.format(solver_class_name) warn_msg += 'the state of convergence from "SolveSolutionStep"' IssueDeprecationWarning("AnalysisStage", warn_msg)
def __init__(self, model, custom_settings): super(MeshSolverBase, self).__init__(model, custom_settings) default_settings = KratosMultiphysics.Parameters(""" { "solver_type" : "mesh_solver_structural_similarity", "buffer_size" : 1, "echo_level" : 0, "domain_size" : -1, "model_part_name" : "", "time_stepping" : { }, "model_import_settings" : { "input_type" : "mdpa", "input_filename" : "unknown_name" }, "mesh_motion_linear_solver_settings" : { "solver_type" : "amgcl", "smoother_type":"ilu0", "krylov_type": "gmres", "coarsening_type": "aggregation", "max_iteration": 200, "provide_coordinates": false, "gmres_krylov_space_dimension": 100, "verbosity" : 0, "tolerance": 1e-7, "scaling": false, "block_size": 1, "use_block_matrices_if_possible" : true, "coarse_enough" : 5000 }, "time_order" : 2, "reform_dofs_each_step" : false, "compute_reactions" : false, "calculate_mesh_velocities" : true }""") self.settings.ValidateAndAssignDefaults(default_settings) if custom_settings["calculate_mesh_velocities"].GetBool(): from KratosMultiphysics.kratos_utilities import IssueDeprecationWarning warn_msg = '"calculate_mesh_velocities" is set to true for the Solver\n' warn_msg += 'This feature was moved to MeshMovingApplication.MeshVelocityCalculation and will soon be removed\n' warn_msg += 'from the solver. Please update your code' IssueDeprecationWarning("MeshSolverBase", warn_msg) # Either retrieve the model part from the model or create a new one model_part_name = self.settings["model_part_name"].GetString() if model_part_name == "": raise Exception( 'Please provide the model part name as the "model_part_name" (string) parameter!' ) if self.model.HasModelPart(model_part_name): self.mesh_model_part = self.model.GetModelPart(model_part_name) else: self.mesh_model_part = model.CreateModelPart(model_part_name) domain_size = self.settings["domain_size"].GetInt() if domain_size == -1: raise Exception( 'Please provide the domain size as the "domain_size" (int) parameter!' ) self.mesh_model_part.ProcessInfo.SetValue( KratosMultiphysics.DOMAIN_SIZE, domain_size) self.print_on_rank_zero("::[MeshSolverBase]:: Construction finished")
def __init__(self, settings, solver_wrappers, process_info): IssueDeprecationWarning( 'CreatePointLoadModelPart', 'please use CreatePointBasedEntitiesProcess" instead') super().__init__(settings, process_info) self.model = solver_wrappers[self.settings["solver"].GetString()].model
from KratosMultiphysics.kratos_utilities import IssueDeprecationWarning IssueDeprecationWarning('EigenSolversApplication', 'please use the "LinearSolversApplication" instead') from KratosMultiphysics.LinearSolversApplication import * from KratosMultiphysics.LinearSolversApplication import dense_linear_solver_factory