KratosOptimizationApplication 10.4.4__py3-none-any.whl

KratosMultiphysics/OptimizationApplication/utilities/logger_utilities.py

@@ -0,0 +1,222 @@
+#    |  /           |
+#    ' /   __| _` | __|  _ \   __|
+#    . \  |   (   | |   (   |\__ `
+#   _|\_\_|  \__,_|\__|\___/ ____/
+#                   Multi-Physics
+#
+#  License:		 BSD License
+#					 license: OptimizationApplication/license.txt
+#
+#  Main authors:    Suneth Warnakulasuriya
+#
+
+import time as timer
+import datetime
+import KratosMultiphysics as Kratos
+from functools import wraps
+import typing
+
+
+def AddFileLoggerOutput(logger_file_name):
+    logger_file = Kratos.FileLoggerOutput(logger_file_name)
+    default_severity = Kratos.Logger.GetDefaultOutput().GetSeverity()
+    Kratos.Logger.GetDefaultOutput().SetSeverity(Kratos.Logger.Severity.WARNING)
+    Kratos.Logger.AddOutput(logger_file)
+
+    return default_severity, logger_file
+
+def RemoveFileLoggerOutput(default_severity, logger_file):
+    Kratos.Logger.Flush()
+    Kratos.Logger.RemoveOutput(logger_file)
+    Kratos.Logger.GetDefaultOutput().SetSeverity(default_severity)
+
+class FileLogger:
+    """@brief A context responsible for managing the lifetime of logger files."""
+    def __init__(self, logger_file_name: str):
+        self.__logger_file_name = logger_file_name
+
+    def __enter__(self):
+        self.__default_severity, self.__logger_file = AddFileLoggerOutput(self.__logger_file_name)
+
+    def __exit__(self, exit_type, exit_value, exit_traceback):
+        RemoveFileLoggerOutput(self.__default_severity, self.__logger_file)
+
+class TimeLogger:
+    """@brief A context responsible for outputting execution times."""
+    def __init__(self, topic: str, entry_msg: str , exit_msg: str, end_new_line: bool=True):
+        self.topic = topic
+        self.entry_msg = entry_msg
+        self.exit_msg = exit_msg
+        self.start_time = None
+        self.end_new_line = end_new_line
+
+    def __enter__(self):
+        if self.entry_msg is not None:
+            Kratos.Logger.PrintInfo(self.topic, self.entry_msg)
+        self.start_time = timer.time()
+
+    def __exit__(self, exit_type, exit_value, exit_traceback):
+        if self.exit_msg is not None:
+            elapsed_time = timer.time() - self.start_time
+            if self.end_new_line:
+                Kratos.Logger.PrintInfo(self.topic, "{:s} - [ Elapsed time: {:s} ]".format(self.exit_msg, str(datetime.timedelta(seconds=round(elapsed_time))))+"\n")
+            else:
+                Kratos.Logger.PrintInfo(self.topic, "{:s} - [ Elapsed time: {:s} ]".format(self.exit_msg, str(datetime.timedelta(seconds=round(elapsed_time)))))
+
+class OptimizationAlgorithmTimeLogger:
+    """@brief A context responsible for outputting execution times."""
+    def __init__(self, optimizer_name: str, optimization_itr: int):
+        self.start_time = None
+        self.optimization_itr = optimization_itr
+        self.optimizer_name = optimizer_name
+
+    def __enter__(self):
+        self.start_time = timer.time()
+
+    def __exit__(self, exit_type, exit_value, exit_traceback):
+
+        current_time = timer.time()
+        elapsed_time = current_time - self.start_time
+        elapsed_time_string = str(datetime.timedelta(seconds=round(elapsed_time)))
+
+        iteration_text = f"{self.optimizer_name} EoF Iteration {self.optimization_itr}"
+        iteration_output = f"{'#'}  {iteration_text} [Elapsed Time: {elapsed_time_string}]  {'#'}"
+
+        divided_line = len(iteration_output) * '#'
+
+        to_print = f"{divided_line}\n{iteration_output}\n{divided_line}\n"
+
+        Kratos.Logger.PrintInfo(to_print)
+
+class OptimizationAnalysisTimeLogger:
+
+    def __enter__(self):
+        start_text = "Optimization Start"
+
+        self.start_time = datetime.datetime.now()
+        start_time_string = self.start_time.strftime("%Y-%m-%d %H:%M:%S")
+
+        time_string = f"**   {start_time_string}   **"
+        separator_string = len(time_string) * '*'
+        center_string = f"**{start_text.center(len(str(time_string))-4)}**"
+        final_string = f"{separator_string}\n{center_string}\n{time_string}\n{separator_string}"
+
+        Kratos.Logger.PrintInfo(final_string)
+
+    def __exit__(self, exit_type, exit_value, exit_traceback):
+
+        end_text = "Optimization End"
+
+        end_time = datetime.datetime.now()
+        end_time_string = end_time.strftime("%Y-%m-%d %H:%M:%S")
+
+        elapsed_time = end_time - self.start_time
+        elapsed_time_string = str(datetime.timedelta(seconds=round(elapsed_time.total_seconds())))
+
+        time_string = f"**   {end_time_string}  [Elapsed Time: {elapsed_time_string}]   **"
+        separator_string = len(time_string) * '*'
+        center_string = f"**{end_text.center(len(str(time_string))-4)}**"
+        final_string = f"{separator_string}\n{center_string}\n{time_string}\n{separator_string}"
+
+        Kratos.Logger.PrintInfo(final_string)
+
+def DictLogger(title: str, data: dict):
+
+    # First do the formatting and converting to strings
+    for key, value in data.items():
+        if isinstance(value, (float, int)):
+            if abs(value) >= 1e6 or abs(value) < 1e-6:
+                data[key] = "{:.6e}".format(value)
+            else:
+                data[key] = "{:.6f}".format(value)
+
+    # Determine the maximum length of labels
+    max_label_len = max(len(str(label)) for label in data.keys())
+    max_value_len = max(len(str(value)) for value in data.values())
+
+    title_len = len(str(title)) + 8
+
+    # Calculate the row width
+    if title_len > max_label_len + max_value_len + 7:
+        row_width = title_len
+        max_value_len = row_width - max_label_len - 7
+    else:
+        row_width = max_label_len + max_value_len + 7
+
+    # Create format strings for the labels and values
+    label_format = f"| {{:<{max_label_len}}} |"
+
+    # Build the table
+    table = '-' * row_width + "\n"
+    table += f"|{str(title).center(row_width - 2)}|\n"
+    table += '-' * row_width + "\n"
+
+    # Add the data to the table
+    for label, value in data.items():
+        table += f"{label_format.format(label)} {value:>{max_value_len}} |\n"
+
+    table += '-' * row_width
+
+    # now print
+    Kratos.Logger.PrintInfo(table)
+
+def ListLogger(title: str, data: 'list[tuple[str, typing.Union[int, float, str]]]'):
+    # First do the formatting and converting to strings
+    sting_data: 'list[tuple[str, typing.Union[int, float, str]]]' = []
+    for key, value in data:
+        if isinstance(value, (float, int)):
+            if abs(value) >= 1e6 or abs(value) < 1e-6:
+                sting_data.append((key, "{:.6e}".format(value)))
+            else:
+                sting_data.append((key, "{:.6f}".format(value)))
+
+    # Determine the maximum length of labels
+    max_label_len = max(len(str(label)) for label, _  in data)
+    max_value_len = max(len(str(value)) for _, value in data)
+
+    title_len = len(str(title)) + 8
+
+    # Calculate the row width
+    if title_len > max_label_len + max_value_len + 7:
+        row_width = title_len
+        max_value_len = row_width - max_label_len - 7
+    else:
+        row_width = max_label_len + max_value_len + 7
+
+    # Create format strings for the labels and values
+    label_format = f"| {{:<{max_label_len}}} |"
+
+    # Build the table
+    table = '-' * row_width + "\n"
+    table += f"|{str(title).center(row_width - 2)}|\n"
+    table += '-' * row_width + "\n"
+
+    # Add the data to the table
+    for label, value in data:
+        table += f"{label_format.format(label)} {value:>{max_value_len}} |\n"
+
+    table += '-' * row_width
+
+    # now print
+    Kratos.Logger.PrintInfo(table)
+
+def time_decorator(arg1=None, arg2=None, methodName=None):
+    def inner_func(func):
+        @wraps(func)
+        def wrapper(self,*args, **kwargs):
+            start_time = timer.perf_counter()
+            if arg1:
+                Kratos.Logger.Print(f"{func.__qualname__.split('.')[0]}::{func.__name__}: {arg1}")
+            result = func(self,*args, **kwargs)
+            end_time = timer.perf_counter()
+            elapsed_time = end_time - start_time
+            if arg2:
+                Kratos.Logger.Print(f"{func.__qualname__.split('.')[0]}::{func.__name__}: {arg2} - [ Elapsed time: {datetime.timedelta(seconds=round(elapsed_time))}] \n")
+            elif methodName:
+                method_to_call = getattr(self, methodName)
+                Kratos.Logger.Print(f"{func.__qualname__.split('.')[0]}::{func.__name__}: {method_to_call()} finished - [ Elapsed time: {datetime.timedelta(seconds=round(elapsed_time))}] \n")
+            else:
+                Kratos.Logger.Print(f"{func.__qualname__.split('.')[0]}::{func.__name__}: Finished - [ Elapsed time: {datetime.timedelta(seconds=round(elapsed_time))}] \n")
+            return result
+        return wrapper
+    return inner_func

KratosMultiphysics/OptimizationApplication/utilities/model_part_utilities.py

@@ -0,0 +1,117 @@
+from typing import Any
+from enum import Enum
+import KratosMultiphysics as Kratos
+import KratosMultiphysics.OptimizationApplication as KratosOA
+
+class ModelPartOperation:
+    class OperationType(Enum):
+        UNION = 1,
+        INTERSECT = 2
+
+    def __init__(self, model: Kratos.Model, operation_type: OperationType, suggested_model_part_name: str, list_of_operation_model_part_full_names: 'list[str]', add_neighbours: bool) -> None:
+        self.model = model
+        self.operation_type = operation_type
+        self.suggested_model_part_name = suggested_model_part_name
+        self.list_of_operation_model_part_full_names = sorted(list(set(list_of_operation_model_part_full_names)))
+        self.add_neighbours = add_neighbours
+
+        if len(list_of_operation_model_part_full_names) == 0:
+            raise RuntimeError("No operating model part names are provided.")
+
+        if suggested_model_part_name.find("#") != -1 or any([mp_name.find("#") != -1 for mp_name in list_of_operation_model_part_full_names]):
+            # find '#' in the model part names which is not allowed.
+            raise RuntimeError(f"The model part names cannot contain '#' character. Parsed model part names are as followings:\n\t suggested model part name: \"{suggested_model_part_name}\"\n\toperation model part names:\n\t" + "\n\t\t".join(list_of_operation_model_part_full_names))
+
+        # set the root model part. This needs to always exist.
+        self.root_model_part = self.model[self.list_of_operation_model_part_full_names[0].split(".")[0]]
+        self.status_msg = ""
+
+    def GetRootModelPart(self) -> Kratos.ModelPart:
+        return self.root_model_part
+
+    def GetModelPartFullName(self) -> str:
+        # check whether is there a need to perform binary operations
+        if self.operation_type == ModelPartOperation.OperationType.UNION or self.operation_type == ModelPartOperation.OperationType.INTERSECT:
+            if len(self.list_of_operation_model_part_full_names) == 1:
+                # all the operation model parts are the same, hence no need of doing an operation.
+                self.status_msg = ""
+                return self.list_of_operation_model_part_full_names[0]
+
+        # now check in the status messages of the root model part whether this operation is already added.
+        status_msg_prefix = "ModelPartUtilities_created#"
+        status_msg_suffix = f"#{self.operation_type.name}#{self.add_neighbours:d}#" + "#".join(self.list_of_operation_model_part_full_names)
+        status_msg_log = KratosOA.OptAppModelPartUtils.GetModelPartStatusLog(self.GetRootModelPart())
+        for status_msg in status_msg_log:
+            if status_msg.startswith(status_msg_prefix) and status_msg.endswith(status_msg_suffix):
+                # found the same operation done on a different model part, hence sending that name
+                self.status_msg = status_msg
+                full_model_part_name = f"{self.GetRootModelPart().FullName()}.{status_msg.split('#')[1]}"
+                Kratos.Logger.PrintInfo("ModelPartUtilities", f"Using \"{full_model_part_name}\" with the same operation instead of suggested model part with name = \"{self.GetRootModelPart().FullName()}.{self.suggested_model_part_name}\".")
+                return full_model_part_name
+
+        # it is not already called for creation. Then put that in the status msg.
+        if self.root_model_part.HasSubModelPart(self.suggested_model_part_name):
+            # this means, it already has a model part with suggested name, but
+            # it does not match the operation identifier. So throw an error
+            raise RuntimeError(f"Found an already existing submodel part named \"{self.suggested_model_part_name}\" in {self.root_model_part.FullName()} without the required operation identifier = \"{status_msg_suffix}\".")
+
+        self.status_msg = f"{status_msg_prefix}{self.suggested_model_part_name}{status_msg_suffix}"
+        KratosOA.OptAppModelPartUtils.LogModelPartStatus(self.GetRootModelPart(), self.status_msg)
+        return f"{self.GetRootModelPart().FullName()}.{self.suggested_model_part_name}"
+
+    def GetModelPart(self) -> Kratos.ModelPart:
+        model_part_name = self.GetModelPartFullName()
+        if self.status_msg == "" or self.model.HasModelPart(model_part_name):
+            # if it is already there, that means it is already created. Hence return it or
+            # if the self.status_msg == "" means, there is no need to do any model part operations.
+            # therefore the model part should exist already.
+            return self.model[model_part_name]
+        else:
+            # the model part with the required operation not found. Hence creating it.
+            sub_model_part = self.model.CreateModelPart(model_part_name)
+            # now fill the submodel part
+            operation_model_parts = [self.model[name] for name in self.list_of_operation_model_part_full_names]
+            if self.operation_type == ModelPartOperation.OperationType.UNION:
+                Kratos.ModelPartOperationUtilities.Union(sub_model_part, self.root_model_part, operation_model_parts, self.add_neighbours)
+            elif self.operation_type == ModelPartOperation.OperationType.INTERSECT:
+                Kratos.ModelPartOperationUtilities.Intersect(sub_model_part, self.root_model_part, operation_model_parts, self.add_neighbours)
+
+            Kratos.Logger.PrintInfo("ModelPartUtilities", f"Created sub model part \"{sub_model_part.FullName()}\".")
+
+            return sub_model_part
+
+class ModelPartUtilities:
+    @staticmethod
+    def __GenerateUniqueIdentifier(prefix: str, list_of_names: 'list[str]', add_neighbours: bool) -> str:
+        if not all([name.find("#") == -1 for name in list_of_names]):
+            raise RuntimeError(f"The provided model part names has \"#\" which is invalid. Please remove all occurances of \"#\" character. Provided model part names:\n\t" + "\n\t".join(list_of_names))
+
+        sorted_names = sorted(list_of_names)
+        post_fix = "IN" if add_neighbours else "EN"
+        return (f"{prefix}_{post_fix}_" + "_".join(sorted_names)).replace(".", "-")
+
+    @staticmethod
+    def GetMergedMap(input_dict: 'dict[Any, KratosOA.CollectiveExpression]', add_neghbours: bool) -> 'dict[Any, Kratos.ModelPart]':
+        result: 'dict[Any, Kratos.ModelPart]' = {}
+        for k, v in input_dict.items():
+            merging_model_part_names = [container_expression.GetModelPart().FullName() for container_expression in v.GetContainerExpressions()]
+
+            if not merging_model_part_names:
+                raise RuntimeError("Merging requires atleast one model part.")
+
+            uniqe_identifier_name = ModelPartUtilities.__GenerateUniqueIdentifier("UNION", merging_model_part_names, add_neghbours)
+            merged_model_part = ModelPartOperation(v.GetContainerExpressions()[0].GetModelPart().GetModel(), ModelPartOperation.OperationType.UNION, uniqe_identifier_name, merging_model_part_names, add_neghbours).GetModelPart()
+            result[k] = merged_model_part
+
+        return result
+
+    @staticmethod
+    def GetIntersectedMap(main_model_part: Kratos.ModelPart, input_dict: 'dict[Any, Kratos.ModelPart]', add_neghbours: bool) -> 'dict[Any, Kratos.ModelPart]':
+        result: 'dict[Any, Kratos.ModelPart]' = {}
+        for k, v in input_dict.items():
+            intersecting_model_part_names = [main_model_part.FullName(), v.FullName()]
+            uniqe_identifier_name = ModelPartUtilities.__GenerateUniqueIdentifier("INTERSECT", intersecting_model_part_names, add_neghbours)
+            intersected_model_part = ModelPartOperation(main_model_part.GetModel(), ModelPartOperation.OperationType.INTERSECT, uniqe_identifier_name, intersecting_model_part_names, add_neghbours).GetModelPart()
+            result[k] = intersected_model_part
+
+        return result

KratosMultiphysics/OptimizationApplication/utilities/opt_line_search.py

@@ -0,0 +1,173 @@
+import KratosMultiphysics as Kratos
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem import OptimizationProblem
+from KratosMultiphysics.OptimizationApplication.utilities.component_data_view import ComponentDataView
+from KratosMultiphysics.OptimizationApplication.utilities.logger_utilities import DictLogger
+from KratosMultiphysics.OptimizationApplication.utilities.logger_utilities import time_decorator
+import numpy
+
+import math
+
+def CreateLineSearch(parameters: Kratos.Parameters, optimization_problem: OptimizationProblem):
+    type = parameters["type"].GetString()
+    if type == "const_step":
+        return ConstStep(parameters, optimization_problem)
+    elif type == "BB_step":
+        return BBStep(parameters, optimization_problem)
+    elif type == "QNBB_step":
+        return QNBBStep(parameters, optimization_problem)
+    else:
+        raise RuntimeError(f"CreateConvergenceCriteria: unsupported convergence type {type}.")
+
+class ConstStep():
+    @classmethod
+    def GetDefaultParameters(cls):
+        return Kratos.Parameters("""{
+            "type"               : "const_step",
+            "init_step"          : 0,
+            "gradient_scaling": ": inf_norm"
+        }""")
+
+    def __init__(self, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem):
+        parameters.ValidateAndAssignDefaults(self.GetDefaultParameters())
+        self._init_step = parameters["init_step"].GetDouble()
+        self._optimization_problem = optimization_problem
+        self._gradient_scaling = parameters["gradient_scaling"].GetString()
+        self.unscaled_step = self._init_step
+
+    def ComputeScaleFactor(self) -> float:
+        algorithm_buffered_data = ComponentDataView("algorithm", self._optimization_problem).GetBufferedData()
+
+        if not algorithm_buffered_data.HasValue("search_direction"):
+            raise RuntimeError(f"Algorithm data does not contain computed \"search_direction\".\nData:\n{algorithm_buffered_data}" )
+
+        search_direction: Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor = algorithm_buffered_data["search_direction"]
+        if self._gradient_scaling == "inf_norm":
+            return numpy.max(numpy.abs(search_direction.data))
+        elif self._gradient_scaling == "l2_norm":
+            return numpy.linalg.norm(search_direction.data)
+        elif self._gradient_scaling == "none":
+            return 1.0
+        else:
+            raise RuntimeError("\"gradient_scaling\" has unknown type.")
+
+    @time_decorator()
+    def ComputeStep(self) -> Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor:
+        norm = self.ComputeScaleFactor()
+        if not math.isclose(norm, 0.0, abs_tol=1e-16):
+            self.step = self._init_step / norm
+        else:
+            self.step =  self._init_step
+
+        DictLogger("Line Search info",self.GetInfo())
+
+        algorithm_buffered_data = ComponentDataView("algorithm", self._optimization_problem).GetBufferedData()
+        step = Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor(algorithm_buffered_data["search_direction"])
+        step.data[:] = self.step
+        return step
+
+    def GetInfo(self) -> dict:
+        info = {'type': 'constant',
+                'unscaled_step': self.unscaled_step,
+                'scaled_step': self.step}
+        return info
+
+class BBStep(ConstStep):
+    @classmethod
+    def GetDefaultParameters(cls):
+        return Kratos.Parameters("""{
+            "type"               : "BB_step",
+            "init_step"          : 0,
+            "max_step"           : 0,
+            "gradient_scaling"   : "inf_norm"
+        }""")
+
+    def __init__(self, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem):
+        parameters.ValidateAndAssignDefaults(self.GetDefaultParameters())
+        self._init_step = parameters["init_step"].GetDouble()
+        self._max_step = parameters["max_step"].GetDouble()
+        self._optimization_problem = optimization_problem
+        self._gradient_scaling = parameters["gradient_scaling"].GetString()
+
+    @time_decorator()
+    def ComputeStep(self) -> Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor:
+        algorithm_buffered_data = ComponentDataView("algorithm", self._optimization_problem).GetBufferedData()
+        norm = self.ComputeScaleFactor()
+        if math.isclose(norm, 0.0, abs_tol=1e-16):
+            norm = 1.0
+        if self._optimization_problem.GetStep() == 0:
+            self.step = self._init_step / norm
+        else:
+            current_search_direction: Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor = algorithm_buffered_data.GetValue("search_direction", 0)
+            previous_search_direction: Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor = algorithm_buffered_data.GetValue("search_direction", 1)
+            y = previous_search_direction.data - current_search_direction.data
+            d: Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor = algorithm_buffered_data.GetValue("control_field_update", 1)
+            dy = numpy.inner(d.data[:].ravel(), y.ravel())
+            dd = numpy.inner(d.data[:].ravel(), d.data[:].ravel())
+            if math.isclose(dy, 0.0, abs_tol=1e-16):
+                self.step = self._max_step / norm
+            else:
+                self.step = abs( dd / dy )
+
+            if self.step > self._max_step / norm:
+                self.step = self._max_step / norm
+
+        DictLogger("Line Search info",self.GetInfo())
+
+        algorithm_buffered_data = ComponentDataView("algorithm", self._optimization_problem).GetBufferedData()
+        step = Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor(algorithm_buffered_data["search_direction"])
+        step.data[:] = self.step
+        return step
+
+    def GetInfo(self) -> dict:
+        info = {'type': 'BB_step',
+                'step': self.step,
+                'max_step': self._max_step,
+                'init_step': self._init_step}
+
+        return info
+
+class QNBBStep(BBStep):
+    @time_decorator()
+    def ComputeStep(self) -> Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor:
+        algorithm_buffered_data = ComponentDataView("algorithm", self._optimization_problem).GetBufferedData()
+        norm = self.ComputeScaleFactor()
+        if math.isclose(norm, 0.0, abs_tol=1e-16):
+            norm = 1.0
+        self.step = Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor(algorithm_buffered_data.GetValue("search_direction", 0), perform_store_data_recursively=False)
+        self.step.data[:] = 0.0
+        if not algorithm_buffered_data.HasValue("step_size"):
+            algorithm_buffered_data["step_size"] = self.step
+
+        if self._optimization_problem.GetStep() == 0:
+            self.step.data[:] = self._init_step / norm
+        else:
+            current_search_direction: Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor = algorithm_buffered_data.GetValue("search_direction", 0)
+            previous_search_direction: Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor = algorithm_buffered_data.GetValue("search_direction", 1)
+            y = previous_search_direction.data - current_search_direction.data
+            d: Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor = algorithm_buffered_data.GetValue("control_field_update", 1)
+            d = d.data[:]
+            for i in range(len(y)):
+                dy = numpy.dot(d[i], y[i])
+                dd = numpy.dot(d[i], d[i])
+
+                if math.isclose(dy, 0.0, abs_tol=1e-16):
+                    self.step.data[i] = self._max_step / norm
+                else:
+                    self.step.data[i] = abs( dd / dy )
+
+                if isinstance(d[i], (float, int, numpy.float64)) and self.step.data[i] > self._max_step / norm:
+                    self.step.data[i] = self._max_step / norm
+                elif isinstance(d[i], (numpy.ndarray)) and self.step.data[i][0] > self._max_step / norm:
+                        self.step.data[i] = self._max_step / norm
+
+        DictLogger("Line Search info",self.GetInfo())
+        self.step.StoreData()
+        return self.step
+
+    def GetInfo(self) -> dict:
+        info = {'type': 'QNBB_step',
+                # 'max scaled_step': self.step.max(),
+                'max_step': self._max_step,
+                'init_step': self._init_step}
+
+        return info