KratosRomApplication 10.4.4__py3-none-any.whl

KratosMultiphysics/RomApplication/__init__.py

@@ -0,0 +1,9 @@
+# Application dependent names and paths
+from KratosMultiphysics import _ImportApplication
+import KratosMultiphysics.LinearSolversApplication
+from KratosRomApplication import *
+
+application = KratosRomApplication()
+application_name = "KratosRomApplication"
+
+_ImportApplication(application, application_name)

KratosMultiphysics/RomApplication/auxiliary_functions_workflow.py

@@ -0,0 +1,20 @@
+import dislib as ds
+from dislib.data.array import Array
+
+def load_blocks_array(blocks, shape, block_size):
+    if shape[0] < block_size[0] or  shape[1] < block_size[1]:
+        raise ValueError("The block size is greater than the ds-array")
+    return Array(blocks, shape=shape, top_left_shape=block_size,
+                     reg_shape=block_size, sparse=False)
+
+def load_blocks_rechunk(blocks, shape, block_size, new_block_size):
+    if shape[0] < new_block_size[0] or  shape[1] < new_block_size[1]:
+        raise ValueError("The block size requested for rechunk"
+                         "is greater than the ds-array")
+    final_blocks = [[]]
+    # Este bucle lo puse por si los Future objects se guardan en una lista, en caso de que la forma de guardarlos cambie, también cambiará un poco este bucle.
+    # Si blocks se pasa ya como (p. ej) [[Future_object, Future_object]] no hace falta.
+    for block in blocks:
+        final_blocks[0].append(block)
+    arr = load_blocks_array(final_blocks, shape, block_size)
+    return arr.rechunk(new_block_size)

KratosMultiphysics/RomApplication/calculate_rom_basis_output_process.py

@@ -0,0 +1,224 @@
+# Import Python modules
+import json
+import numpy
+from pathlib import Path
+
+# Importing the Kratos Library
+import KratosMultiphysics
+from KratosMultiphysics.RomApplication.randomized_singular_value_decomposition import RandomizedSingularValueDecomposition
+
+def Factory(settings, model):
+    if not isinstance(settings, KratosMultiphysics.Parameters):
+        raise Exception("Expected input shall be a Parameters object, encapsulating a json string.")
+    return CalculateRomBasisOutputProcess(model, settings["Parameters"])
+
+class CalculateRomBasisOutputProcess(KratosMultiphysics.OutputProcess):
+    """A process to set the snapshots matrix and calculate the ROM basis from it."""
+
+    def __init__(self, model, settings):
+        KratosMultiphysics.OutputProcess.__init__(self)
+
+        # Validate input settings against defaults
+        settings.ValidateAndAssignDefaults(self.GetDefaultParameters())
+
+        # Get the model part from which the snapshots are to be retrieved
+        if not settings["model_part_name"].GetString():
+            raise Exception("\'model_part_name\' not provided. Please specify the model part to get the snapshots from.")
+        self.model_part = model[settings["model_part_name"].GetString()]
+
+        # Set the snapshots output control and interval
+        snapshots_control_type = settings["snapshots_control_type"].GetString()
+        if snapshots_control_type == "time":
+            self.snapshots_control_is_time = True
+        elif snapshots_control_type == "step":
+            self.snapshots_control_is_time = False
+        else:
+            err_msg = "Unknown value \'{}\' for \'snapshots_control_type\'. Available options are \'time\' and \'step\'.".format(snapshots_control_type)
+            raise Exception(err_msg)
+        self.snapshots_interval = settings["snapshots_interval"].GetDouble()
+
+        # Get the variables list to be used to get the snapshots matrix information
+        # Note that we sort the snapshot variables list alphabetically
+        # This is required in order to establish a consensum for the possible visualization model part projections
+        nodal_unknowns = settings["nodal_unknowns"].GetStringArray()
+        if len(nodal_unknowns) == 0:
+            err_msg = "The snapshots matrix variables need to be specified by the user in the \'nodal_unknowns\' string array."
+            raise Exception(err_msg)
+        if any(nodal_unknowns.count(var_name) > 1 for var_name in nodal_unknowns):
+            err_msg = "There are repeated variables in the \'nodal_unknowns\' string array."
+            raise Exception(err_msg)
+        nodal_unknowns.sort()
+
+        self.snapshot_variables_list = []
+        for var_name in nodal_unknowns:
+            if not KratosMultiphysics.KratosGlobals.HasVariable(var_name):
+                err_msg = "\'{}\' variable in \'nodal_unknowns\' is not in KratosGlobals. Please check provided value.".format(var_name)
+            if not KratosMultiphysics.KratosGlobals.GetVariableType(var_name):
+                err_msg = "\'{}\' variable in \'nodal_unknowns\' is not double type. Please check provide double type variables (e.g. [\"DISPLACEMENT_X\",\"DISPLACEMENT_Y\"]).".format(var_name)
+            self.snapshot_variables_list.append(KratosMultiphysics.KratosGlobals.GetVariable(var_name))
+
+        # Set the ROM basis output settings
+        self.rom_basis_output_format = settings["rom_basis_output_format"].GetString()
+        rom_basis_output_available_formats = ["json", "numpy"]
+        if self.rom_basis_output_format not in rom_basis_output_available_formats:
+            err_msg = "Provided \'rom_basis_output_format\' is {}. Available options are \'json\' and \'numpy\'.".format(self.rom_basis_output_format)
+            raise Exception(err_msg)
+
+        self.rom_basis_output_name = settings["rom_basis_output_name"].GetString()
+
+        self.rom_basis_output_folder = Path(settings["rom_basis_output_folder"].GetString())
+
+        # Get the SVD truncation tolerance
+        self.svd_truncation_tolerance = settings["svd_truncation_tolerance"].GetDouble()
+
+        # Initialize output interval data
+        self.next_output = 0.0
+
+        # Initialize the snapshots data list
+        self.snapshots_data_list = []
+
+        # Set the flag allowing to run multiple simulations using this process #TODO cope with arbitrarily large cases (parallelism)
+        self.rom_manager = settings["rom_manager"].GetBool()
+
+        # Set the flag to print the Singular Values vector corresponding to the SVD modes
+        self.print_singular_values = settings["print_singular_values"].GetBool()
+        if self.print_singular_values and self.rom_basis_output_format == "json":
+            err_msg = 'Cannot print singular values if using the "json" output format for CalculateRomBasisOutputProcess. Please use "numpy" instead.'
+            raise Exception(err_msg)
+
+
+    @classmethod
+    def GetDefaultParameters(self):
+        default_settings = KratosMultiphysics.Parameters("""{
+            "help": "A process to set the snapshots matrix and calculate the ROM basis from it.",
+            "model_part_name": "",
+            "rom_manager" : false,
+            "snapshots_control_type": "step",
+            "snapshots_interval": 1.0,
+            "nodal_unknowns": [],
+            "rom_basis_output_format": "numpy",
+            "rom_basis_output_name": "RomParameters",
+            "rom_basis_output_folder" : "rom_data",
+            "svd_truncation_tolerance": 1.0e-6,
+            "print_singular_values": false
+        }""")
+
+        return default_settings
+
+    def IsOutputStep(self):
+        if self.snapshots_control_is_time:
+            time = self.__GetPrettyFloat(self.model_part.ProcessInfo[KratosMultiphysics.TIME])
+            return time >= self.__GetPrettyFloat(self.next_output)
+        else:
+            step = self.__GetPrettyFloat(self.model_part.ProcessInfo[KratosMultiphysics.STEP])
+            return step >= self.next_output
+
+    def PrintOutput(self):
+        # Save the data in the snapshots data list
+        aux_data_array = []
+        for snapshot_var in self.snapshot_variables_list:
+            aux_data_array.append( numpy.array(KratosMultiphysics.VariableUtils().GetSolutionStepValuesVector(self.model_part.Nodes, snapshot_var, 0), copy=False ))
+        self.snapshots_data_list.append(numpy.stack(aux_data_array, axis=1).reshape(-1,1))
+
+
+        # Schedule next snapshot output
+        if self.snapshots_interval > 0.0: # Note: if == 0, we'll just always print
+            if self.snapshots_control_is_time:
+                time = self.__GetPrettyFloat(self.model_part.ProcessInfo[KratosMultiphysics.TIME])
+                while self.__GetPrettyFloat(self.next_output) <= time:
+                    self.next_output += self.snapshots_interval
+            else:
+                step = self.__GetPrettyFloat(self.model_part.ProcessInfo[KratosMultiphysics.STEP])
+                while self.next_output <= step:
+                    self.next_output += self.snapshots_interval
+
+
+    def _GetSnapshotsMatrix(self):
+        return numpy.block(self.snapshots_data_list)
+
+
+    def _ComputeSVD(self, snapshots_matrix):
+
+        # Calculate the randomized SVD of the snapshots matrix
+        u,sigma,_,_= RandomizedSingularValueDecomposition().Calculate(snapshots_matrix, self.svd_truncation_tolerance)
+        return u, sigma
+
+
+    def _PrintRomBasis(self, u, sigma):
+        # Initialize the Python dictionary with the default settings
+        # Note that this order is kept if Python 3.6 onwards is used
+        rom_basis_dict = {
+            "rom_manager" : False,
+            "train_hrom": False,
+            "run_hrom": False,
+            "projection_strategy": "galerkin",
+            "assembling_strategy": "global",
+            "rom_format": "numpy",
+            "rom_settings": {
+                "rom_bns_settings": {}
+            },
+            "hrom_settings": {},
+            "nodal_modes": {},
+            "elements_and_weights" : {}
+        }
+        #TODO: I'd rename elements_and_weights to hrom_weights
+
+        if self.rom_manager:
+            rom_basis_dict["rom_manager"] = True
+        rom_basis_dict["hrom_settings"]["hrom_format"] = self.rom_basis_output_format
+        n_nodal_unknowns = len(self.snapshot_variables_list)
+
+        # Save the nodal basis
+        rom_basis_dict["rom_settings"]["nodal_unknowns"] = [var.Name() for var in self.snapshot_variables_list]
+        rom_basis_dict["rom_settings"]["number_of_rom_dofs"] = numpy.shape(u)[1] #TODO: This is way misleading. I'd call it number_of_basis_modes or number_of_rom_modes
+        rom_basis_dict["projection_strategy"] = "galerkin" # Galerkin: (Phi.T@K@Phi dq= Phi.T@b), LSPG = (K@Phi dq= b), Petrov-Galerkin = (Psi.T@K@Phi dq = Psi.T@b)
+        rom_basis_dict["assembling_strategy"] = "global" # Assemble the ROM globally or element by element: "global" (Phi_g @ J_g @ Phi_g), "element by element" sum(Phi_e^T @ K_e @ Phi_e)
+        rom_basis_dict["rom_format"] = self.rom_basis_output_format
+        rom_basis_dict["rom_settings"]["petrov_galerkin_number_of_rom_dofs"] = 0
+        #NOTE "petrov_galerkin_number_of_rom_dofs" is not used unless a Petrov-Galerkin simulation is called, in which case it shall be modified either manually or from the RomManager
+
+        # Create the folder if it doesn't already exist
+        if not self.rom_basis_output_folder.exists():
+            self.rom_basis_output_folder.mkdir(parents=True)
+
+        if self.rom_basis_output_format == "json":
+            # Storing modes in JSON format
+            i = 0
+            for node in self.model_part.Nodes:
+                rom_basis_dict["nodal_modes"][node.Id] = u[i:i+n_nodal_unknowns].tolist()
+                i += n_nodal_unknowns
+
+        elif self.rom_basis_output_format == "numpy":
+            # Storing modes in Numpy format
+            node_ids = []
+            for node in self.model_part.Nodes:
+                node_ids.append(node.Id)
+            node_ids = numpy.array(node_ids)
+            numpy.save(self.rom_basis_output_folder / "RightBasisMatrix.npy", u)
+            numpy.save(self.rom_basis_output_folder / "NodeIds.npy", node_ids)
+            if self.print_singular_values:
+                numpy.save(self.rom_basis_output_folder / "SingularValuesVector.npy", sigma)
+        else:
+            err_msg = "Unsupported output format {}.".format(self.rom_basis_output_format)
+            raise Exception(err_msg)
+
+        # Creating the ROM JSON file containing or not the modes depending on "self.rom_basis_output_format"
+        output_filename = self.rom_basis_output_folder / f"{self.rom_basis_output_name}.json"
+        with output_filename.open('w') as f:
+            json.dump(rom_basis_dict, f, indent = 4)
+
+
+    def ExecuteFinalize(self):
+        # Prepare a NumPy array with the snapshots data
+        self.n_nodes = self.model_part.NumberOfNodes()
+        self.n_data_cols = len(self.snapshots_data_list)
+        self.n_nodal_unknowns = len(self.snapshot_variables_list)
+
+        if not self.rom_manager:
+            u, sigma = self._ComputeSVD(self._GetSnapshotsMatrix())
+            self._PrintRomBasis(u, sigma)
+
+    def __GetPrettyFloat(self, number):
+        float_format = "{:.12f}"
+        pretty_number = float(float_format.format(number))
+        return pretty_number

KratosMultiphysics/RomApplication/empirical_cubature_method.py

@@ -0,0 +1,290 @@
+import numpy as np
+from KratosMultiphysics import Logger
+
+try:
+    from matplotlib import pyplot as plt
+    missing_matplotlib = False
+except ImportError as e:
+    missing_matplotlib = True
+
+
+class EmpiricalCubatureMethod():
+    """
+    This class selects a subset of elements and corresponding positive weights necessary for the construction of a hyper-reduced order model
+    Reference: Hernandez 2020. "A multiscale method for periodic structures using domain decomposition and ECM-hyperreduction"
+    """
+
+    def __init__(
+        self,
+        ECM_tolerance = 0,
+        Filter_tolerance = 0,
+        Plotting = False,
+        MaximumNumberUnsuccesfulIterations = 100
+    ):
+        """
+        Constructor setting up the parameters for the Element Selection Strategy
+            ECM_tolerance: approximation tolerance for the element selection algorithm
+            Filter_tolerance: parameter limiting the number of candidate points (elements) to those above this tolerance
+            Plotting: whether to plot the error evolution of the element selection algorithm
+        """
+        self.ECM_tolerance = ECM_tolerance
+        self.Filter_tolerance = Filter_tolerance
+        self.Name = "EmpiricalCubature"
+        self.Plotting = Plotting
+        self.MaximumNumberUnsuccesfulIterations = MaximumNumberUnsuccesfulIterations
+
+    def SetUp(
+        self,
+        ResidualsBasis,
+        InitialCandidatesSet = None,
+        constrain_sum_of_weights=True,
+        constrain_conditions = False,
+        number_of_conditions = 0
+    ):
+        """
+        Method for setting up the element selection
+        input:  - ResidualsBasis: numpy array containing a basis to the residuals projected
+                - constrain_sum_of_weights: enable the user to constrain weights to be the sum of the number of entities.
+                - constrain_conditions: enable the user to enforce weights to consider conditions (for specific boundary conditions).
+        """
+        self.W = np.ones(np.shape(ResidualsBasis)[0])
+        self.G = ResidualsBasis.T
+        self.y = InitialCandidatesSet
+        self.add_constrain_count = None
+        total_number_of_entities = np.shape(self.G)[1]
+        elements_constraint = np.ones(total_number_of_entities)
+        conditions_begin = total_number_of_entities - number_of_conditions
+        elements_constraint[conditions_begin:] = 0
+
+        if constrain_sum_of_weights and not constrain_conditions:
+            """
+            -This is necessary in case the sum of the columns of self.G equals the 0 vector,to avoid the trivial solution
+            -It is enforcing that the sum of the weights equals the number of columns in self.G (total number of elements)
+            """
+            projection_of_constant_vector_elements = elements_constraint - self.G.T@( self.G @ elements_constraint)
+            projection_of_constant_vector_elements/= np.linalg.norm(projection_of_constant_vector_elements)
+            self.G = np.vstack([ self.G , projection_of_constant_vector_elements] )
+            self.add_constrain_count = -1
+        elif constrain_sum_of_weights and constrain_conditions:#Only for models which contains conditions
+            projection_of_constant_vector_elements = elements_constraint - self.G.T@( self.G @ elements_constraint)
+            projection_of_constant_vector_elements/= np.linalg.norm(projection_of_constant_vector_elements)
+            self.G = np.vstack([ self.G , projection_of_constant_vector_elements] )
+            # # # # # # # # #
+            conditions_constraint = np.ones(total_number_of_entities)
+            conditions_constraint[:conditions_begin] = 0
+            projection_of_constant_vector_conditions = conditions_constraint - self.G.T@( self.G @ conditions_constraint)
+            projection_of_constant_vector_conditions/= np.linalg.norm(projection_of_constant_vector_conditions)
+            self.G = np.vstack([ self.G , projection_of_constant_vector_conditions ] )
+            self.add_constrain_count = -2
+        self.b = self.G @ self.W
+        self.UnsuccesfulIterations = 0
+
+    def Initialize(self):
+        """
+        Method performing calculations required before launching the Calculate method
+        """
+        self.GnormNOONE = np.linalg.norm(self.G[:self.add_constrain_count,:], axis = 0)
+        M = np.shape(self.G)[1]
+        normB = np.linalg.norm(self.b)
+
+        if self.y is None:
+            self.y = np.arange(0,M,1) # Set of candidate points (those whose associated column has low norm are removed)
+
+            if self.Filter_tolerance > 0:
+                TOL_REMOVE = self.Filter_tolerance * normB
+                rmvpin = np.where(self.GnormNOONE[self.y] < TOL_REMOVE)
+                #self.y_complement = self.y[rmvpin]
+                self.y = np.delete(self.y,rmvpin)
+        else:
+            self.y_complement = np.arange(0, M, 1)  # Initialize complement with all points
+            self.y_complement = np.delete(self.y_complement, self.y)  # Remove candidates from complement
+
+            if self.Filter_tolerance > 0:
+                TOL_REMOVE = self.Filter_tolerance * normB  # Compute removal tolerance
+
+                # Filter out low-norm columns from complement
+                rmvpin_complement = np.where(self.GnormNOONE[self.y_complement] < TOL_REMOVE)
+                self.y_complement = np.delete(self.y_complement, rmvpin_complement)
+
+                # Filter out low-norm columns from candidates
+                rmvpin = np.where(self.GnormNOONE[self.y] < TOL_REMOVE)
+                removed_count = np.size(rmvpin)
+                self.y = np.delete(self.y, rmvpin)
+
+                # Warning if some candidates were removed
+                if removed_count > 0:
+                    Logger.PrintWarning("EmpiricalCubatureMethod", f"Some of the candidates were removed ({removed_count} removed). To include all candidates (with 0 weights in the HROM model part) for visualization and projection, consider using 'include_elements_model_parts_list' and 'include_conditions_model_parts_list' in the 'hrom_settings'.")
+
+                # Warning if all candidates were removed
+                if np.size(self.y) == 0:
+                    Logger.PrintWarning("EmpiricalCubatureMethod", "All candidates were removed because they have no contribution to the residual. To include them all (with 0 weights in the HROM model part) for visualization and projection, use 'include_elements_model_parts_list' and 'include_conditions_model_parts_list' in the 'hrom_settings'.")
+                    self.y = self.y_complement  # Set candidates to complement
+
+        self.z = {}  # Set of intergration points
+        self.mPOS = 0 # Number of nonzero weights
+        self.r = self.b.copy() # residual vector
+        self.m = len(self.b) # Default number of points
+        self.nerror = np.linalg.norm(self.r)/normB
+        self.nerrorACTUAL = self.nerror
+
+    def Run(self):
+        self.Initialize()
+        self.Calculate()
+
+    def expand_candidates_with_complement(self):
+        self.y = np.r_[self.y,self.y_complement]
+        print('expanding set to include the complement...')
+        ExpandedSetFlag = True
+        return ExpandedSetFlag
+
+    def Calculate(self):
+        """
+        Method launching the element selection algorithm to find a set of elements: self.z, and wiegths: self.w
+        """
+        MaximumLengthZ = 0
+        ExpandedSetFlag = False
+        k = 1 # number of iterations
+        self.success = True
+        while self.nerrorACTUAL > self.ECM_tolerance and self.mPOS < self.m and np.size(self.y) != 0:
+
+            if  self.UnsuccesfulIterations >  self.MaximumNumberUnsuccesfulIterations and not ExpandedSetFlag and hasattr(self, 'y_complement'):
+                ExpandedSetFlag = self.expand_candidates_with_complement()
+
+            #Step 1. Compute new point
+            if np.size(self.y)==1:
+                #candidate set consists of a single element
+                indSORT = 0
+                i = int(self.y)
+            else:
+                ObjFun = self.G[:,self.y].T @ self.r.T
+                ObjFun = ObjFun.T #/ self.GnormNOONE[self.y]
+                indSORT = np.argmax(ObjFun)
+                i = self.y[indSORT]
+            if k==1:
+                alpha = np.linalg.lstsq(self.G[:, [i]], self.b)[0]
+                H = 1/(self.G[:,i] @ self.G[:,i].T)
+            else:
+                H, alpha = self._UpdateWeightsInverse(self.G[:,self.z],H,self.G[:,i],alpha)
+
+            #Step 3. Move i from set y to set z
+            if k == 1:
+                self.z = i
+            else:
+                self.z = np.r_[self.z,i]
+
+            #self.y = np.delete(self.y,indSORT)
+            if np.size(self.y)==1:
+                if hasattr(self, 'y_complement'):
+                    self.expand_candidates_with_complement()
+                    self.y = np.delete(self.y,indSORT)
+                else:
+                    self.success = False
+                    break
+            else:
+                self.y = np.delete(self.y,indSORT)
+
+            # Step 4. Find possible negative weights
+            if any(alpha < 0):
+                print("WARNING: NEGATIVE weight found")
+                indexes_neg_weight = np.where(alpha <= 0.)[0]
+                self.y = np.append(self.y, (self.z[indexes_neg_weight]).T)
+                self.z = np.delete(self.z, indexes_neg_weight)
+                H = self._MultiUpdateInverseHermitian(H, indexes_neg_weight)
+                alpha = H @ (self.G[:, self.z].T @ self.b)
+                alpha = alpha.reshape(len(alpha),1)
+
+            if np.size(self.z) > MaximumLengthZ :
+                self.UnsuccesfulIterations = 0
+            else:
+                self.UnsuccesfulIterations += 1
+
+            #Step 6 Update the residual
+            if np.size(alpha)==1:
+                self.r = self.b.reshape(-1,1) - (self.G[:,self.z] * alpha).reshape(-1,1)
+                self.r = np.squeeze(self.r)
+            else:
+                Aux = self.G[:,self.z] @ alpha
+                self.r = np.squeeze(self.b - Aux.T)
+            self.nerror = np.linalg.norm(self.r) / np.linalg.norm(self.b)  # Relative error (using r and b)
+            self.nerrorACTUAL = self.nerror
+
+            # STEP 7
+            self.mPOS = np.size(self.z)
+            print(f'k = {k}, m = {np.size(self.z)}, error n(res)/n(b) (%) = {self.nerror*100},  Actual error % = {self.nerrorACTUAL*100} ')
+
+            if k == 1:
+                ERROR_GLO = np.array([self.nerrorACTUAL])
+                NPOINTS = np.array([np.size(self.z)])
+            else:
+                ERROR_GLO = np.c_[ ERROR_GLO , self.nerrorACTUAL]
+                NPOINTS = np.c_[ NPOINTS , np.size(self.z)]
+
+            MaximumLengthZ = max(MaximumLengthZ, np.size(self.z))
+            k = k+1
+
+            if k-MaximumLengthZ>1000 and ExpandedSetFlag:
+                """
+                this means using the initial candidate set, it was impossible to obtain a set of positive weights.
+                Try again without constraints!!!
+                TODO: incorporate this into greater workflow
+                """
+                self.success = False
+                break
+
+        self.w = alpha.T * np.sqrt(self.W[self.z]) #TODO FIXME cope with weights vectors different from 1
+
+        print(f'Total number of iterations = {k}')
+
+        if missing_matplotlib == False and self.Plotting == True:
+            plt.plot(NPOINTS[0], ERROR_GLO[0])
+            plt.title('Element Selection Error Evolution')
+            plt.xlabel('Number of elements')
+            plt.ylabel('Error %')
+            plt.show()
+
+    def _UpdateWeightsInverse(self, A,Aast,a,xold):
+        """
+        Method for the quick update of weights (self.w), whenever a negative weight is found
+        """
+        c = np.dot(A.T, a)
+        d = np.dot(Aast, c).reshape(-1, 1)
+        s = np.dot(a.T, a) - np.dot(c.T, d)
+        aux1 = np.hstack([Aast + np.outer(d, d) / s, -d / s])
+        if np.shape(-d.T / s)[1]==1:
+            s = s.reshape(1,-1)
+            aux2 = np.squeeze(np.hstack([-d.T / s, 1 / s]))
+        else:
+            aux2 = np.hstack([np.squeeze(-d.T / s), 1 / s])
+        Bast = np.vstack([aux1, aux2])
+        v = np.dot(a.T, self.r) / s
+        x = np.vstack([(xold - d * v), v])
+        return Bast, x
+
+    def _MultiUpdateInverseHermitian(self, invH, neg_indexes):
+        """
+        Method for the quick update of weights (self.w), whenever a negative weight is found
+        """
+        neg_indexes = np.sort(neg_indexes)
+        for i in range(np.size(neg_indexes)):
+            neg_index = neg_indexes[i] - i
+            invH = self._UpdateInverseHermitian(invH, neg_index)
+        return invH
+
+    def _UpdateInverseHermitian(self, invH, neg_index):
+        """
+        Method for the quick update of weights (self.w), whenever a negative weight is found
+        """
+        if neg_index == np.shape(invH)[1]:
+            aux = (invH[0:-1, -1] * invH[-1, 0:-1]) / invH(-1, -1)
+            invH_new = invH[:-1, :-1] - aux
+        else:
+            aux1 = np.hstack([invH[:, 0:neg_index], invH[:, neg_index + 1:], invH[:, neg_index].reshape(-1, 1)])
+            aux2 = np.vstack([aux1[0:neg_index, :], aux1[neg_index + 1:, :], aux1[neg_index, :]])
+            invH_new = aux2[0:-1, 0:-1] - np.outer(aux2[0:-1, -1], aux2[-1, 0:-1]) / aux2[-1, -1]
+        return invH_new
+
+
+
+
+
+