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","."]
code: def _update_results(self, main_iterator, saved_logl, saved_nodeids):
      if self.log:
          self.logger.info(
              "Likelihood function evaluations: %d", self.ncall
          )
  
      results = combine_results(
          saved_logl,
          saved_nodeids,
          self.pointpile,
          main_iterator,
          mpi_comm=self.comm if self.use_mpi else None,
      )
  
      results["ncall"] = int(self.ncall)
      results["paramnames"] = self.paramnames + self.derivedparamnames
      results["logzerr_single"] = (
          main_iterator.all_H[0] / self.min_num_live_points
      ) ** 0.5
  
      sequence, results2 = logz_sequence(
          self.root,
          self.pointpile,
          random=True,
          check_insertion_order=True,
      )
      results["insertion_order_MWW_test"] = results2[
          "insertion_order_MWW_test"
      ]
  
      results_simple = dict(results)
      weighted_samples = results_simple.pop("weighted_samples")
      samples = results_simple.pop("samples")
      saved_wt0 = weighted_samples["weights"]
      saved_u = weighted_samples["upoints"]
      saved_v = weighted_samples["points"]
  
      if self.log_to_disk:
          if self.log:
              self.logger.info(
                  "Writing samples and results to disk ..."
              )
          np.savetxt(
              os.path.join(
                  self.logs["chains"], "equal_weighted_post.txt"
              ),
              samples,
              header=" ".join(self.paramnames + self.derivedparamnames),
              comments="",
          )
          np.savetxt(
              os.path.join(self.logs["chains"], "weighted_post.txt"),
              np.hstack(
                  (
                      saved_wt0.reshape((-1, 1)),
                      np.reshape(saved_logl, (-1, 1)),
                      saved_v,
                  )
              ),
              header=" ".join(
                  ["weight", "logl"]
                  + self.paramnames
                  + self.derivedparamnames
              ),
              comments="",
          )
          np.savetxt(
              os.path.join(
                  self.logs["chains"], "weighted_post_untransformed.txt"
              ),
              np.hstack(
                  (
                      saved_wt0.reshape((-1, 1)),
                      np.reshape(saved_logl, (-1, 1)),
                      saved_u,
                  )
              ),
              header=" ".join(
                  ["weight", "logl"]
                  + self.paramnames
                  + self.derivedparamnames
              ),
              comments="",
          )
  
          with open(
              os.path.join(self.logs["info"], "results.json"), "w"
          ) as f:
              json.dump(results_simple, f, indent=4)
  
          np.savetxt(
              os.path.join(self.logs["info"], "post_summary.csv"),
              [
                  [
                      results["posterior"][k][i]
                      for i in range(self.num_params)
                      for k in (
                          "mean",
                          "stdev",
                          "median",
                          "errlo",
                          "errup",
                      )
                  ]
              ],
              header=",".join(
                  [
                      '"{0}_mean","{0}_stdev","{0}_median","{0}_errlo","{0}_errup"'.format(
                          k
                      )
                      for k in self.paramnames + self.derivedparamnames
                  ]
              ),
              delimiter=",",
              comments="",
          )
  
      if self.log_to_disk:
          keys = (
              "logz",
              "logzerr",
              "logvol",
              "nlive",
              "logl",
              "logwt",
              "insert_order",
          )
          np.savetxt(
              os.path.join(self.logs["chains"], "run.txt"),
              np.hstack(
                  tuple(
                      [np.reshape(sequence[k], (-1, 1)) for k in keys]
                  )
              ),
              header=" ".join(keys),
              comments="",
          )
          if self.log:
              self.logger.info(
                  "Writing samples and results to disk ... done"
              )
  
      self.results = results
      self.run_sequence = sequence
  
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 17 for calling the ReactiveNestedSampler obj's underlying member method code with example usage: obj._update_results(main_iterator, saved_logl, saved_nodeids) without return types