docstr: This processing method can optionally minimise only the best candidate
  solutions in the minimiser pool
  
  Parameters
  ----------
  force_iter : int
               Number of starting minimisers to process (can be sepcified
               globally or locally)
docstr_tok: ["This","processing","method","can","optionally","minimise","only","the","best","candidate","solutions","in","the","minimiser","pool","Parameters","--","--","--","--","--","force_iter",":","int","Number","of","starting","minimisers","to","process","(","can","be","sepcified","globally","or","locally",")"]
code: def minimise_pool(self, force_iter=False):
      """
      This processing method can optionally minimise only the best candidate
      solutions in the minimiser pool
  
      Parameters
      ----------
      force_iter : int
                   Number of starting minimisers to process (can be sepcified
                   globally or locally)
  
      """
      # Find first local minimum
      # NOTE: Since we always minimize this value regardless it is a waste to
      # build the topograph first before minimizing
      lres_f_min = self.minimize(
          self.X_min[0], ind=self.minimizer_pool[0]
      )
  
      # Trim minimised point from current minimiser set
      self.trim_min_pool(0)
  
      # Force processing to only
      if force_iter:
          self.local_iter = force_iter
  
      while not self.stop_l_iter:
          # Global stopping criteria:
          if self.f_min_true is not None:
              if (lres_f_min.fun - self.f_min_true) / abs(
                  self.f_min_true
              ) <= self.f_tol:
                  self.stop_l_iter = True
                  break
          # Note first iteration is outside loop:
          if self.local_iter is not None:
              if self.disp:
                  logging.info(
                      "SHGO.iters in function minimise_pool = {}".format(
                          self.local_iter
                      )
                  )
              self.local_iter -= 1
              if self.local_iter == 0:
                  self.stop_l_iter = True
                  break
  
          if np.shape(self.X_min)[0] == 0:
              self.stop_l_iter = True
              break
  
          # Construct topograph from current minimiser set
          # (NOTE: This is a very small topograph using only the miniser pool
          #        , it might be worth using some graph theory tools instead.
          self.g_topograph(lres_f_min.x, self.X_min)
  
          # Find local minimum at the miniser with the greatest euclidean
          # distance from the current solution
          ind_xmin_l = self.Z[:, -1]
          lres_f_min = self.minimize(
              self.Ss[-1, :], self.minimizer_pool[-1]
          )
  
          # Trim minimised point from current minimiser set
          self.trim_min_pool(ind_xmin_l)
  
      # Reset controls
      self.stop_l_iter = False
      return
  
imports: from __future__ import division, print_function, absolute_import
  import numpy
  import time
  import logging
  import warnings
  from scipy import spatial
  from scipy.optimize import OptimizeResult, minimize
  from scipy.optimize._shgo_lib import sobol_seq
  from scipy.optimize._shgo_lib.triangulation import Complex
label_desc: Use image node_id 17 for calling the SHGO obj's underlying member method code with example usage: obj.minimise_pool(force_iter) without return types