class_docstr: Nested sampler with reactive exploration strategy.
  
  Storage & resume capable, optionally MPI parallelised.
class_docstr_tok: ["Nested","sampler","with","reactive","exploration","strategy",".","Storage","&","resume","capable",",","optionally","MPI","parallelised","."]
docstr: Draw a new point above likelihood threshold `Lmin`.
  
  Parameters
  -----------
  Lmin: float
      loglikelihood threshold to draw above
  ndraw: float
      number of points to try to sample at once
  active_u: array of floats
      current live points
  active_values: array
      loglikelihoods of current live points
docstr_tok: ["Draw","a","new","point","above","likelihood","threshold","`","Lmin","`",".","Parameters","--","--","--","--","--","-","Lmin",":","float","loglikelihood","threshold","to","draw","above","ndraw",":","float","number","of","points","to","try","to","sample","at","once","active_u",":","array","of","floats","current","live","points","active_values",":","array","loglikelihoods","of","current","live","points"]
code: def _create_point(self, Lmin, ndraw, active_u, active_values):
      """Draw a new point above likelihood threshold `Lmin`.
  
      Parameters
      -----------
      Lmin: float
          loglikelihood threshold to draw above
      ndraw: float
          number of points to try to sample at once
      active_u: array of floats
          current live points
      active_values: array
          loglikelihoods of current live points
  
      """
      if self.stepsampler is None:
          assert self.region.inside(active_u).any(), (
              "None of the live points satisfies the current region!",
              self.region.maxradiussq,
              self.region.u,
              self.region.unormed,
              active_u,
              getattr(self.region, "bbox_lo"),
              getattr(self.region, "bbox_hi"),
              getattr(self.region, "ellipsoid_cov"),
              getattr(self.region, "ellipsoid_center"),
              getattr(self.region, "ellipsoid_invcov"),
              getattr(self.region, "ellipsoid_cov"),
          )
  
      nit = 0
      while True:
          ib = self.ib
          if ib >= len(self.samples) and self.use_point_stack:
              # root checks the point store
              next_point = (
                  np.zeros((1, 3 + self.x_dim + self.num_params))
                  * np.nan
              )
  
              if self.log_to_pointstore:
                  _, stored_point = self.pointstore.pop(Lmin)
                  if stored_point is not None:
                      next_point[0, :] = stored_point
                  else:
                      next_point[0, :] = -np.inf
                  self.use_point_stack = not self.pointstore.stack_empty
  
              if self.use_mpi:  # and informs everyone
                  self.use_point_stack = self.comm.bcast(
                      self.use_point_stack, root=0
                  )
                  next_point = self.comm.bcast(next_point, root=0)
  
              # unpack
              self.likes = next_point[:, 1]
              self.samples = next_point[:, 3 : 3 + self.x_dim]
              self.samplesv = next_point[
                  :, 3 + self.x_dim : 3 + self.x_dim + self.num_params
              ]
              # skip if we already know it is not useful
              ib = 0 if np.isfinite(self.likes[0]) else 1
  
          use_stepsampler = self.stepsampler is not None
          while ib >= len(self.samples):
              ib = 0
              if use_stepsampler:
                  u, v, logl, nc = self.stepsampler.__next__(
                      self.region,
                      transform=self.transform,
                      loglike=self.loglike,
                      Lmin=Lmin,
                      us=active_u,
                      Ls=active_values,
                      ndraw=ndraw,
                      tregion=self.tregion,
                  )
                  quality = self.stepsampler.nsteps
              else:
                  u, v, logl, nc, quality = self._refill_samples(
                      Lmin, ndraw, nit
                  )
              nit += 1
  
              if logl is None:
                  u = np.empty((0, self.x_dim))
                  v = np.empty((0, self.num_params))
                  logl = np.empty((0,))
              elif u.ndim == 1:
                  assert np.logical_and(u > 0, u < 1).all(), u
                  u = u.reshape((1, self.x_dim))
                  v = v.reshape((1, self.num_params))
                  logl = logl.reshape((1,))
  
              if self.use_mpi:
                  recv_samples = self.comm.gather(u, root=0)
                  recv_samplesv = self.comm.gather(v, root=0)
                  recv_likes = self.comm.gather(logl, root=0)
                  recv_nc = self.comm.gather(nc, root=0)
                  recv_samples = self.comm.bcast(recv_samples, root=0)
                  recv_samplesv = self.comm.bcast(recv_samplesv, root=0)
                  recv_likes = self.comm.bcast(recv_likes, root=0)
                  recv_nc = self.comm.bcast(recv_nc, root=0)
                  self.samples = np.concatenate(recv_samples, axis=0)
                  self.samplesv = np.concatenate(recv_samplesv, axis=0)
                  self.likes = np.concatenate(recv_likes, axis=0)
                  self.ncall += sum(recv_nc)
              else:
                  self.samples = u
                  self.samplesv = v
                  self.likes = logl
                  self.ncall += nc
  
              if self.log:
                  for ui, vi, logli in zip(
                      self.samples, self.samplesv, self.likes
                  ):
                      self.pointstore.add(
                          _listify([Lmin, logli, quality], ui, vi),
                          self.ncall,
                      )
  
          if self.likes[ib] > Lmin:
              u = self.samples[ib, :]
              assert np.logical_and(u > 0, u < 1).all(), u
              p = self.samplesv[ib, :]
              logl = self.likes[ib]
  
              self.ib = ib + 1
              return u, p, logl
          else:
              self.ib = ib + 1
  
imports: from __future__ import print_function, division
  import os
  import sys
  import csv
  import json
  import operator
  import time
  import warnings
  from numpy import log, exp, logaddexp
  import numpy
  from .utils import create_logger, make_run_dir, resample_equal, vol_prefactor, vectorize, listify
  from .utils import is_affine_transform, normalised_kendall_tau_distance, distributed_work_chunk_size
  from ultranest.mlfriends import MLFriends, AffineLayer, ScalingLayer, find_nearby, WrappingEllipsoid, RobustEllipsoidRegion
  from .store import HDF5PointStore, TextPointStore, NullPointStore
  from .viz import get_default_viz_callback
  from .ordertest import UniformOrderAccumulator
  from .netiter import PointPile, SingleCounter, MultiCounter, BreadthFirstIterator, TreeNode, count_tree_between, find_nodes_before, logz_sequence
  from .netiter import dump_tree, combine_results
  from .hotstart import get_auxiliary_contbox_parameterization
label_desc: Use image node_id 11 for calling the ReactiveNestedSampler obj's underlying member method code with example usage: obj._create_point(Lmin, ndraw, active_u, active_values) and returns: u,  p,  logl