text: #! /usr/bin/env python
  
  # Licensed under an MIT style license -- see LICENSE.md
  
  import numpy as np
  import os
  import importlib
  from multiprocessing import Pool, Manager
  
  from pesummary.core.plots.latex_labels import latex_labels
  from pesummary.utils.utils import (
      logger, get_matplotlib_backend, make_dir, get_matplotlib_style_file
  )
  from pesummary.core.plots import plot as core
  from pesummary.core.plots import interactive
  
  import matplotlib
  
  __author__ = ["Charlie Hoy <charlie.hoy@ligo.org>"]
  matplotlib.use(get_matplotlib_backend(parallel=True))
  matplotlib.style.use(get_matplotlib_style_file())
  
  
  class _PlotGeneration(object):
      """Super class to handle the plot generation for a given set of result
      files
  
      Parameters
      ----------
      savedir: str
          the directory to store the plots
      webdir: str
          the web directory of the run
      labels: list
          list of labels used to distinguish the result files
      samples: dict
          dictionary of posterior samples stored in the result files
      kde_plot: Bool
          if True, kde plots are generated instead of histograms, Default False
      existing_labels: list
          list of labels stored in an existing metafile
      existing_injection_data: dict
          dictionary of injection data stored in an existing metafile
      existing_samples: dict
          dictionary of posterior samples stored in an existing metafile
      same_parameters: list
          list of paramerers that are common in all result files
      injection_data: dict
          dictionary of injection data for each result file
      result_files: list
          list of result files passed
      colors: list
          colors that you wish to use to distinguish different result files
      disable_comparison: bool, optional
          whether to make comparison plots, default is True.
          if disable_comparison is False and len(labels) == 1, no comparsion plots
          will be generated
      disable_interactive: bool, optional
          whether to make interactive plots, default is False
      disable_corner: bool, optional
          whether to make the corner plot, default is False
      """
      def __init__(
          self, savedir=None, webdir=None, labels=None, samples=None,
          kde_plot=False, existing_labels=None, existing_injection_data=None,
          existing_samples=None, existing_weights=None, same_parameters=None,
          injection_data=None, colors=None, custom_plotting=None,
          add_to_existing=False, priors={}, include_prior=False, weights=None,
          disable_comparison=False, linestyles=None, disable_interactive=False,
          multi_process=1, mcmc_samples=False, disable_corner=False,
          corner_params=None, expert_plots=True, checkpoint=False
      ):
          self.package = "core"
          self.webdir = webdir
          make_dir(self.webdir)
          make_dir(os.path.join(self.webdir, "plots", "corner"))
          self.savedir = savedir
          self.labels = labels
          self.mcmc_samples = mcmc_samples
          self.samples = samples
          self.kde_plot = kde_plot
          self.existing_labels = existing_labels
          self.existing_injection_data = existing_injection_data
          self.existing_samples = existing_samples
          self.existing_weights = existing_weights
          self.same_parameters = same_parameters
          self.injection_data = injection_data
          self.colors = colors
          self.custom_plotting = custom_plotting
          self.add_to_existing = add_to_existing
          self.priors = priors
          self.include_prior = include_prior
          self.linestyles = linestyles
          self.make_interactive = not disable_interactive
          self.make_corner = not disable_corner
          self.corner_params = corner_params
          self.expert_plots = expert_plots
          if self.mcmc_samples and self.expert_plots:
              logger.warning("Unable to generate expert plots for mcmc samples")
              self.expert_plots = False
          self.checkpoint = checkpoint
          self.multi_process = multi_process
          self.pool = self.setup_pool()
          self.preliminary_pages = {label: False for label in self.labels}
          self.preliminary_comparison_pages = False
          self.make_comparison = (
              not disable_comparison and self._total_number_of_labels > 1
          )
          self.weights = (
              weights if weights is not None else {i: None for i in self.labels}
          )
  
          if self.same_parameters is not None and not self.mcmc_samples:
              self.same_samples = {
                  param: {
                      key: item[param] for key, item in self.samples.items()
                  } for param in self.same_parameters
              }
          else:
              self.same_samples = None
  
          for i in self.samples.keys():
              try:
                  self.check_latex_labels(
                      self.samples[i].keys(remove_debug=False)
                  )
              except TypeError:
                  pass
  
          self.plot_type_dictionary = {
              "oned_histogram": self.oned_histogram_plot,
              "sample_evolution": self.sample_evolution_plot,
              "autocorrelation": self.autocorrelation_plot,
              "oned_cdf": self.oned_cdf_plot,
              "custom": self.custom_plot
          }
          if self.make_corner:
              self.plot_type_dictionary.update({"corner": self.corner_plot})
          if self.expert_plots:
              self.plot_type_dictionary.update({"expert": self.expert_plot})
          if self.make_comparison:
              self.plot_type_dictionary.update(dict(
                  oned_histogram_comparison=self.oned_histogram_comparison_plot,
                  oned_cdf_comparison=self.oned_cdf_comparison_plot,
                  box_plot_comparison=self.box_plot_comparison_plot,
              ))
          if self.make_interactive:
              self.plot_type_dictionary.update(
                  dict(
                      interactive_corner=self.interactive_corner_plot
                  )
              )
              if self.make_comparison:
                  self.plot_type_dictionary.update(
                      dict(
                          interactive_ridgeline=self.interactive_ridgeline_plot
                      )
                  )
  
      @staticmethod
      def save(fig, name, preliminary=False, close=True, format="png"):
          """Save a figure to disk.
  
          Parameters
          ----------
          fig: matplotlib.pyplot.figure
              Matplotlib figure that you wish to save
          name: str
              Name of the file that you wish to write it too
          close: Bool, optional
              Close the figure after it has been saved
          format: str, optional
              Format used to save the image
          """
          n = len(format)
          if ".%s" % (format) != name[-n - 1:]:
              name += ".%s" % (format)
          if preliminary:
              fig.text(
                  0.5, 0.5, 'Preliminary', fontsize=90, color='gray', alpha=0.1,
                  ha='center', va='center', rotation='30'
              )
          fig.tight_layout()
          fig.savefig(name, format=format)
          if close:
              fig.close()
  
      @property
      def _total_number_of_labels(self):
          _number_of_labels = 0
          for item in [self.labels, self.existing_labels]:
              if isinstance(item, list):
                  _number_of_labels += len(item)
          return _number_of_labels
  
      @staticmethod
      def check_latex_labels(parameters):
          """Check to see if there is a latex label for all parameters. If not,
          then create one
  
          Parameters
          ----------
          parameters: list
              list of parameters
          """
          for i in parameters:
              if i not in list(latex_labels.keys()):
                  latex_labels[i] = i.replace("_", " ")
  
      @property
      def savedir(self):
          return self._savedir
  
      @savedir.setter
      def savedir(self, savedir):
          self._savedir = savedir
          if savedir is None:
              self._savedir = self.webdir + "/plots/"
  
      def setup_pool(self):
          """Setup a pool of processes to speed up plot generation
          """
          pool = Pool(processes=self.multi_process)
          return pool
  
      def generate_plots(self):
          """Generate all plots for all result files
          """
          for i in self.labels:
              logger.debug("Starting to generate plots for {}".format(i))
              self._generate_plots(i)
              if self.make_interactive:
                  logger.debug(
                      "Starting to generate interactive plots for {}".format(i)
                  )
                  self._generate_interactive_plots(i)
          if self.add_to_existing:
              self.add_existing_data()
          if self.make_comparison:
              logger.debug("Starting to generate comparison plots")
              self._generate_comparison_plots()
  
      def check_prior_samples_in_dict(self, label, param):
          """Check to see if there are prior samples for a given param
  
          Parameters
          ----------
          label: str
              the label used to distinguish a given run
          param: str
              name of the parameter you wish to return prior samples for
          """
          cond1 = "samples" in self.priors.keys()
          if cond1 and label in self.priors["samples"].keys():
              cond1 = self.priors["samples"][label] != []
              if cond1 and param in self.priors["samples"][label].keys():
                  return self.priors["samples"][label][param]
              return None
          return None
  
      def add_existing_data(self):
          """
          """
          from pesummary.utils.utils import _add_existing_data
  
          self = _add_existing_data(self)
  
      def _generate_plots(self, label):
          """Generate all plots for a a given result file
          """
          if self.make_corner:
              self.try_to_make_a_plot("corner", label=label)
          self.try_to_make_a_plot("oned_histogram", label=label)
          self.try_to_make_a_plot("sample_evolution", label=label)
          self.try_to_make_a_plot("autocorrelation", label=label)
          self.try_to_make_a_plot("oned_cdf", label=label)
          if self.expert_plots:
              self.try_to_make_a_plot("expert", label=label)
          if self.custom_plotting:
              self.try_to_make_a_plot("custom", label=label)
  
      def _generate_interactive_plots(self, label):
          """Generate all interactive plots and save them to an html file ready
          to be imported later
          """
          self.try_to_make_a_plot("interactive_corner", label=label)
          if self.make_comparison:
              self.try_to_make_a_plot("interactive_ridgeline")
  
      def _generate_comparison_plots(self):
          """Generate all comparison plots
          """
          self.try_to_make_a_plot("oned_histogram_comparison")
          self.try_to_make_a_plot("oned_cdf_comparison")
          self.try_to_make_a_plot("box_plot_comparison")
  
      def try_to_make_a_plot(self, plot_type, label=None):
          """Wrapper function to _try_to_make_a_plot
  
          Parameters
          ----------
          plot_type: str
              String to describe the plot that you wish to try and make
          label: str
              The label of the results file that you wish to plot
          """
          self._try_to_make_a_plot(
              [label], self.plot_type_dictionary[plot_type],
              "Failed to generate %s plot because {}" % (plot_type)
          )
  
      @staticmethod
      def _try_to_make_a_plot(arguments, function, message):
          """Try to make a plot. If it fails return an error message and continue
          plotting
  
          Parameters
          ----------
          arguments: list
              list of arguments that you wish to pass to function
          function: func
              function that you wish to execute
          message: str
              the error message that you wish to be printed.
          """
          try:
              function(*arguments)
          except RuntimeError:
              try:
                  from matplotlib import rcParams
  
                  original = rcParams['text.usetex']
                  rcParams['text.usetex'] = False
                  function(*arguments)
                  rcParams['text.usetex'] = original
              except Exception as e:
                  logger.info(message.format(e))
          except Exception as e:
              logger.info(message.format(e))
          finally:
              from matplotlib import pyplot
  
              pyplot.close()
  
      def corner_plot(self, label):
          """Generate a corner plot for a given result file
  
          Parameters
          ----------
          label: str
              the label for the results file that you wish to plot
          """
          if self.mcmc_samples:
              samples = self.samples[label].combine
          else:
              samples = self.samples[label]
          self._corner_plot(
              self.savedir, label, samples, latex_labels, self.webdir,
              self.corner_params, self.preliminary_pages[label], self.checkpoint
          )
  
      @staticmethod
      def _corner_plot(
          savedir, label, samples, latex_labels, webdir, params, preliminary=False,
          checkpoint=False
      ):
          """Generate a corner plot for a given set of samples
  
          Parameters
          ----------
          savedir: str
              the directory you wish to save the plot in
          label: str
              the label corresponding to the results file
          samples: dict
              dictionary containing PESummary.utils.array.Array objects that
              contain samples for each parameter
          latex_labels: str
              latex labels for each parameter in samples
          webdir: str
              the directory where the `js` directory is located
          preliminary: Bool, optional
              if True, add a preliminary watermark to the plot
          """
          import warnings
  
          with warnings.catch_warnings():
              warnings.simplefilter("ignore")
              filename = os.path.join(
                  savedir, "corner", "{}_all_density_plots.png".format(label)
              )
              if os.path.isfile(filename) and checkpoint:
                  return
              fig, params, data = core._make_corner_plot(
                  samples, latex_labels, corner_parameters=params
              )
              _PlotGeneration.save(
                  fig, filename, preliminary=preliminary
              )
              combine_corner = open(
                  os.path.join(webdir, "js", "combine_corner.js")
              )
              combine_corner = combine_corner.readlines()
              params = [str(i) for i in params]
              ind = [
                  linenumber for linenumber, line in enumerate(combine_corner)
                  if "var list = {}" in line
              ][0]
              combine_corner.insert(
                  ind + 1, "    list['{}'] = {};\n".format(label, params)
              )
              new_file = open(
                  os.path.join(webdir, "js", "combine_corner.js"), "w"
              )
              new_file.writelines(combine_corner)
              new_file.close()
              combine_corner = open(
                  os.path.join(webdir, "js", "combine_corner.js")
              )
              combine_corner = combine_corner.readlines()
              params = [str(i) for i in params]
              ind = [
                  linenumber for linenumber, line in enumerate(combine_corner)
                  if "var data = {}" in line
              ][0]
              combine_corner.insert(
                  ind + 1, "    data['{}'] = {};\n".format(label, data)
              )
              new_file = open(
                  os.path.join(webdir, "js", "combine_corner.js"), "w"
              )
              new_file.writelines(combine_corner)
              new_file.close()
  
      def _mcmc_iterator(self, label, function):
          """If the data is a set of mcmc chains, return a 2d list of samples
          to plot. Otherwise return a list of posterior samples
          """
          if self.mcmc_samples:
              function += "_mcmc"
              return self.same_parameters, self.samples[label], getattr(
                  self, function
              )
          return self.samples[label].keys(), self.samples[label], getattr(
              self, function
          )
  
      def oned_histogram_plot(self, label):
          """Generate oned histogram plots for all parameters in the result file
  
          Parameters
          ----------
          label: str
              the label for the results file that you wish to plot
          """
          import math
  
          error_message = (
              "Failed to generate oned_histogram plot for %s because {}"
          )
  
          iterator, samples, function = self._mcmc_iterator(
              label, "_oned_histogram_plot"
          )
  
          prior = lambda param: self.check_prior_samples_in_dict(
              label, param
          ) if self.include_prior else None
  
          arguments = [
              (
                  [
                      self.savedir, label, param, samples[param],
                      latex_labels[param], self.injection_data[label][param],
                      self.kde_plot, prior(param), self.weights[label],
                      self.package, self.preliminary_pages[label],
                      self.checkpoint
                  ], function, error_message % (param)
              ) for param in iterator
          ]
          self.pool.starmap(self._try_to_make_a_plot, arguments)
  
      def oned_histogram_comparison_plot(self, label):
          """Generate oned comparison histogram plots for all parameters that are
          common to all result files
  
          Parameters
          ----------
          label: str
              the label for the results file that you wish to plot
          """
          error_message = (
              "Failed to generate a comparison histogram plot for %s because {}"
          )
          for param in self.same_parameters:
              injection = [
                  value[param] for value in self.injection_data.values()
              ]
              arguments = [
                  self.savedir, param, self.same_samples[param],
                  latex_labels[param], self.colors, injection, self.kde_plot,
                  self.linestyles, self.package,
                  self.preliminary_comparison_pages, self.checkpoint, None
              ]
              self._try_to_make_a_plot(
                  arguments, self._oned_histogram_comparison_plot,
                  error_message % (param)
              )
              continue
  
      @staticmethod
      def _oned_histogram_comparison_plot(
          savedir, parameter, samples, latex_label, colors, injection, kde=False,
          linestyles=None, package="core", preliminary=False, checkpoint=False,
          filename=None
      ):
          """Generate a oned comparison histogram plot for a given parameter
  
          Parameters
          ----------i
          savedir: str
              the directory you wish to save the plot in
          parameter: str
              the name of the parameter that you wish to make a oned comparison
              histogram for
          samples: dict
              dictionary of pesummary.utils.array.Array objects containing the
              samples that correspond to parameter for each result file. The key
              should be the corresponding label
          latex_label: str
              the latex label for parameter
          colors: list
              list of colors to be used to distinguish different result files
          injection: list
              list of injected values, one for each analysis
          kde: Bool, optional
              if True, kde plots will be generated rather than 1d histograms
          linestyles: list, optional
              list of linestyles used to distinguish different result files
          preliminary: Bool, optional
              if True, add a preliminary watermark to the plot
          """
          import math
          module = importlib.import_module(
              "pesummary.{}.plots.plot".format(package)
          )
          if filename is None:
              filename = os.path.join(
                  savedir, "combined_1d_posterior_{}.png".format(parameter)
              )
          if os.path.isfile(filename) and checkpoint:
              return
          hist = not kde
          for num, inj in enumerate(injection):
              if math.isnan(inj):
                  injection[num] = None
          same_samples = [val for key, val in samples.items()]
          fig = module._1d_comparison_histogram_plot(
              parameter, same_samples, colors, latex_label,
              list(samples.keys()), inj_value=injection, kde=kde,
              linestyles=linestyles, hist=hist
          )
          _PlotGeneration.save(
              fig, filename, preliminary=preliminary
          )
  
      @staticmethod
      def _oned_histogram_plot(
          savedir, label, parameter, samples, latex_label, injection, kde=False,
          prior=None, weights=None, package="core", preliminary=False,
          checkpoint=False
      ):
          """Generate a oned histogram plot for a given set of samples
  
          Parameters
          ----------
          savedir: str
              the directory you wish to save the plot in
          label: str
              the label corresponding to the results file
          parameter: str
              the name of the parameter that you wish to plot
          samples: PESummary.utils.array.Array
              array containing the samples corresponding to parameter
          latex_label: str
              the latex label corresponding to parameter
          injection: float
              the injected value
          kde: Bool, optional
              if True, kde plots will be generated rather than 1d histograms
          prior: PESummary.utils.array.Array, optional
              the prior samples for param
          weights: PESummary.utils.utilsrray, optional
              the weights for each samples. If None, assumed to be 1
          preliminary: Bool, optional
              if True, add a preliminary watermark to the plot
          """
          import math
          module = importlib.import_module(
              "pesummary.{}.plots.plot".format(package)
          )
  
          if math.isnan(injection):
              injection = None
          hist = not kde
  
          filename = os.path.join(
              savedir, "{}_1d_posterior_{}.png".format(label, parameter)
          )
          if os.path.isfile(filename) and checkpoint:
              return
          fig = module._1d_histogram_plot(
              parameter, samples, latex_label, inj_value=injection, kde=kde,
              hist=hist, prior=prior, weights=weights
          )
          _PlotGeneration.save(
              fig, filename, preliminary=preliminary
          )
  
      @staticmethod
      def _oned_histogram_plot_mcmc(
          savedir, label, parameter, samples, latex_label, injection, kde=False,
          prior=None, weights=None, package="core", preliminary=False,
          checkpoint=False
      ):
          """Generate a oned histogram plot for a given set of samples for
          multiple mcmc chains
  
          Parameters
          ----------
          savedir: str
              the directory you wish to save the plot in
          label: str
              the label corresponding to the results file
          parameter: str
              the name of the parameter that you wish to plot
          samples: dict
              dictionary of PESummary.utils.array.Array objects containing the
              samples corresponding to parameter for multiple mcmc chains
          latex_label: str
              the latex label corresponding to parameter
          injection: float
              the injected value
          kde: Bool, optional
              if True, kde plots will be generated rather than 1d histograms
          prior: PESummary.utils.array.Array, optional
              the prior samples for param
          weights: PESummary.utils.array.Array, optional
              the weights for each samples. If None, assumed to be 1
          preliminary: Bool, optional
              if True, add a preliminary watermark to the plot
          """
          import math
          from pesummary.utils.array import Array
  
          module = importlib.import_module(
              "pesummary.{}.plots.plot".format(package)
          )
  
          if math.isnan(injection):
              injection = None
          same_samples = [val for key, val in samples.items()]
          filename = os.path.join(
              savedir, "{}_1d_posterior_{}.png".format(label, parameter)
          )
          if os.path.isfile(filename) and checkpoint:
              pass
          else:
              fig = module._1d_histogram_plot_mcmc(
                  parameter, same_samples, latex_label, inj_value=injection,
                  kde=kde, prior=prior, weights=weights
              )
              _PlotGeneration.save(
                  fig, filename, preliminary=preliminary
              )
          filename = os.path.join(
              savedir, "{}_1d_posterior_{}_combined.png".format(label, parameter)
          )
          if os.path.isfile(filename) and checkpoint:
              pass
          else:
              fig = module._1d_histogram_plot(
                  parameter, Array(np.concatenate(same_samples)), latex_label,
                  inj_value=injection, kde=kde, prior=prior, weights=weights
              )
              _PlotGeneration.save(
                  fig, filename, preliminary=preliminary
              )
  
      def sample_evolution_plot(self, label):
          """Generate sample evolution plots for all parameters in the result file
  
          Parameters
          ----------
          label: str
              the label for the results file that you wish to plot
          """
          error_message = (
              "Failed to generate a sample evolution plot for %s because {}"
          )
          iterator, samples, function = self._mcmc_iterator(
              label, "_sample_evolution_plot"
          )
          arguments = [
              (
                  [
                      self.savedir, label, param, samples[param],
                      latex_labels[param], self.injection_data[label][param],
                      self.preliminary_pages[label], self.checkpoint
                  ], function, error_message % (param)
              ) for param in iterator
          ]
          self.pool.starmap(self._try_to_make_a_plot, arguments)
  
      def expert_plot(self, label):
          """Generate expert plots for diagnostics
  
          Parameters
          ----------
          label: str
              the label for the results file that you wish to plot
          """
          error_message = (
              "Failed to generate log_likelihood-%s 2d contour plot because {}"
          )
          iterator, samples, function = self._mcmc_iterator(
              label, "_2d_contour_plot"
          )
          _debug = self.samples[label].debug_keys()
          arguments = [
              (
                  [
                      self.savedir, label, param, "log_likelihood", samples[param],
                      samples["log_likelihood"], latex_labels[param],
                      latex_labels["log_likelihood"],
                      self.preliminary_pages[label], [
                          samples[param][np.argmax(samples["log_likelihood"])],
                          np.max(samples["log_likelihood"]),
                      ], self.checkpoint
                  ], function, error_message % (param)
              ) for param in iterator + _debug
          ]
          self.pool.starmap(self._try_to_make_a_plot, arguments)
          _reweight_keys = [
              param for param in self.samples[label].debug_keys() if
              "_non_reweighted" in param
          ]
          if len(_reweight_keys):
              error_message = (
                  "Failed to generate %s-%s 2d contour plot because {}"
              )
              _base_param = lambda p: p.split("_non_reweighted")[0][1:]
              arguments = [
                  (
                      [
                          self.savedir, label, _base_param(param), param,
                          samples[_base_param(param)], samples[param],
                          latex_labels[_base_param(param)], latex_labels[param],
                          self.preliminary_pages[label], None, self.checkpoint
                      ], function, error_message % (_base_param(param), param)
                  ) for param in _reweight_keys
              ]
              self.pool.starmap(self._try_to_make_a_plot, arguments)
              error_message = (
                  "Failed to generate a histogram plot comparing %s and %s "
                  "because {}"
              )
              arguments = [
                  (
                      [
                          self.savedir, _base_param(param), {
                              "reweighted": samples[_base_param(param)],
                              "non-reweighted": samples[param]
                          }, latex_labels[_base_param(param)], ['b', 'r'],
                          [np.nan, np.nan], True, None, self.package,
                          self.preliminary_comparison_pages, self.checkpoint,
                          os.path.join(
                              self.savedir, "{}_1d_posterior_{}_{}.png".format(
                                  label, _base_param(param), param
                              )
                          )
                      ], self._oned_histogram_comparison_plot,
                      error_message % (_base_param(param), param)
                  ) for param in _reweight_keys
              ]
              self.pool.starmap(self._try_to_make_a_plot, arguments)
  
          error_message = (
              "Failed to generate log_likelihood-%s sample_evolution plot "
              "because {}"
          )
          iterator, samples, function = self._mcmc_iterator(
              label, "_colored_sample_evolution_plot"
          )
          arguments = [
              (
                  [
                      self.savedir, label, param, "log_likelihood", samples[param],
                      samples["log_likelihood"], latex_labels[param],
                      latex_labels["log_likelihood"],
                      self.preliminary_pages[label], self.checkpoint
                  ], function, error_message % (param)
              ) for param in iterator
          ]
          self.pool.starmap(self._try_to_make_a_plot, arguments)
          error_message = (
              "Failed to generate bootstrapped oned_histogram plot for %s "
              "because {}"
          )
          iterator, samples, function = self._mcmc_iterator(
              label, "_oned_histogram_bootstrap_plot"
          )
          arguments = [
              (
                  [
                      self.savedir, label, param, samples[param],
                      latex_labels[param], self.preliminary_pages[label],
                      self.package, self.checkpoint
                  ], function, error_message % (param)
              ) for param in iterator
          ]
          self.pool.starmap(self._try_to_make_a_plot, arguments)
  
      @staticmethod
      def _oned_histogram_bootstrap_plot(
          savedir, label, parameter, samples, latex_label, preliminary=False,
          package="core", checkpoint=False, nsamples=1000, ntests=100, **kwargs
      ):
          """Generate a bootstrapped oned histogram plot for a given set of
          samples
  
          Parameters
          ----------
          savedir: str
              the directory you wish to save the plot in
          label: str
              the label corresponding to the results file
          parameter: str
              the name of the parameter that you wish to plot
          samples: PESummary.utils.array.Array
              array containing the samples corresponding to parameter
          latex_label: str
              the latex label corresponding to parameter
          preliminary: Bool, optional
              if True, add a preliminary watermark to the plot
          """
          import math
          module = importlib.import_module(
              "pesummary.{}.plots.plot".format(package)
          )
  
          filename = os.path.join(
              savedir, "{}_1d_posterior_{}_bootstrap.png".format(label, parameter)
          )
          if os.path.isfile(filename) and checkpoint:
              return
          fig = module._1d_histogram_plot_bootstrap(
              parameter, samples, latex_label, nsamples=nsamples, ntests=ntests,
              **kwargs
          )
          _PlotGeneration.save(
              fig, filename, preliminary=preliminary
          )
  
      @staticmethod
      def _2d_contour_plot(
          savedir, label, parameter_x, parameter_y, samples_x, samples_y,
          latex_label_x, latex_label_y, preliminary=False, truth=None,
          checkpoint=False
      ):
          """Generate a 2d contour plot for a given set of samples
  
          Parameters
          ----------
          savedir: str
              the directory you wish to save the plot in
          label: str
              the label corresponding to the results file
          samples_x: PESummary.utils.array.Array
              array containing the samples for the x axis
          samples_y: PESummary.utils.array.Array
              array containing the samples for the y axis
          latex_label_x: str
              the latex label for the x axis
          latex_label_y: str
              the latex label for the y axis
          preliminary: Bool, optional
              if True, add a preliminary watermark to the plot
          """
          from pesummary.core.plots.publication import twod_contour_plot
  
          filename = os.path.join(
              savedir, "{}_2d_contour_{}_{}.png".format(
                  label, parameter_x, parameter_y
              )
          )
          if os.path.isfile(filename) and checkpoint:
              return
          fig = twod_contour_plot(
              samples_x, samples_y, levels=[0.9, 0.5], xlabel=latex_label_x,
              ylabel=latex_label_y, bins=50, truth=truth
          )
          _PlotGeneration.save(
              fig, filename, preliminary=preliminary
          )
  
      @staticmethod
      def _colored_sample_evolution_plot(
          savedir, label, parameter_x, parameter_y, samples_x, samples_y,
          latex_label_x, latex_label_y, preliminary=False, checkpoint=False
      ):
          """Generate a 2d contour plot for a given set of samples
  
          Parameters
          ----------
          savedir: str
              the directory you wish to save the plot in
          label: str
              the label corresponding to the results file
          samples_x: PESummary.utils.array.Array
              array containing the samples for the x axis
          samples_y: PESummary.utils.array.Array
              array containing the samples for the y axis
          latex_label_x: str
              the latex label for the x axis
          latex_label_y: str
              the latex label for the y axis
          preliminary: Bool, optional
              if True, add a preliminary watermark to the plot
          """
          filename = os.path.join(
              savedir, "{}_sample_evolution_{}_{}_colored.png".format(
                  label, parameter_x, parameter_y
              )
          )
          if os.path.isfile(filename) and checkpoint:
              return
          fig = core._sample_evolution_plot(
              parameter_x, samples_x, latex_label_x, z=samples_y,
              z_label=latex_label_y
          )
          _PlotGeneration.save(
              fig, filename, preliminary=preliminary
          )
  
      @staticmethod
      def _sample_evolution_plot(
          savedir, label, parameter, samples, latex_label, injection,
          preliminary=False, checkpoint=False
      ):
          """Generate a sample evolution plot for a given set of samples
  
          Parameters
          ----------
          savedir: str
              the directory you wish to save the plot in
          label: str
              the label corresponding to the results file
          parameter: str
              the name of the parameter that you wish to plot
          samples: PESummary.utils.array.Array
              array containing the samples corresponding to parameter
          latex_label: str
              the latex label corresponding to parameter
          injection: float
              the injected value
          preliminary: Bool, optional
              if True, add a preliminary watermark to the plot
          """
          filename = os.path.join(
              savedir, "{}_sample_evolution_{}.png".format(label, parameter)
          )
          if os.path.isfile(filename) and checkpoint:
              return
          fig = core._sample_evolution_plot(
              parameter, samples, latex_label, injection
          )
          _PlotGeneration.save(
              fig, filename, preliminary=preliminary
          )
  
      @staticmethod
      def _sample_evolution_plot_mcmc(
          savedir, label, parameter, samples, latex_label, injection,
          preliminary=False, checkpoint=False
      ):
          """Generate a sample evolution plot for a given set of mcmc chains
  
          Parameters
          ----------
          savedir: str
              the directory you wish to save the plot in
          label: str
              the label corresponding to the results file
          parameter: str
              the name of the parameter that you wish to plot
          samples: dict
              dictionary containing pesummary.utils.array.Array objects containing
              the samples corresponding to parameter for each chain
          latex_label: str
              the latex label corresponding to parameter
          injection: float
              the injected value
          preliminary: Bool, optional
              if True, add a preliminary watermark to the plot
          """
          filename = os.path.join(
              savedir, "{}_sample_evolution_{}.png".format(label, parameter)
          )
          if os.path.isfile(filename) and checkpoint:
              return
          same_samples = [val for key, val in samples.items()]
          fig = core._sample_evolution_plot_mcmc(
              parameter, same_samples, latex_label, injection
          )
          _PlotGeneration.save(
              fig, filename, preliminary=preliminary
          )
  
      def autocorrelation_plot(self, label):
          """Generate autocorrelation plots for all parameters in the result file
  
          Parameters
          ----------
          label: str
              the label for the results file that you wish to plot
          """
          error_message = (
              "Failed to generate an autocorrelation plot for %s because {}"
          )
          iterator, samples, function = self._mcmc_iterator(
              label, "_autocorrelation_plot"
          )
          arguments = [
              (
                  [
                      self.savedir, label, param, samples[param],
                      self.preliminary_pages[label], self.checkpoint
                  ], function, error_message % (param)
              ) for param in iterator
          ]
          self.pool.starmap(self._try_to_make_a_plot, arguments)
  
      @staticmethod
      def _autocorrelation_plot(
          savedir, label, parameter, samples, preliminary=False, checkpoint=False
      ):
          """Generate an autocorrelation plot for a given set of samples
  
          Parameters
          ----------
          savedir: str
              the directory you wish to save the plot in
          label: str
              the label corresponding to the results file
          parameter: str
              the name of the parameter that you wish to plot
          samples: PESummary.utils.array.Array
              array containing the samples corresponding to parameter
          preliminary: Bool, optional
              if True, add a preliminary watermark to the plot
          """
          filename = os.path.join(
              savedir, "{}_autocorrelation_{}.png".format(label, parameter)
          )
          if os.path.isfile(filename) and checkpoint:
              return
          fig = core._autocorrelation_plot(parameter, samples)
          _PlotGeneration.save(
              fig, filename, preliminary=preliminary
          )
  
      @staticmethod
      def _autocorrelation_plot_mcmc(
          savedir, label, parameter, samples, preliminary=False, checkpoint=False
      ):
          """Generate an autocorrelation plot for a list of samples, one for each
          mcmc chain
  
          Parameters
          ----------
          savedir: str
              the directory you wish to save the plot in
          label: str
              the label corresponding to the results file
          parameter: str
              the name of the parameter that you wish to plot
          samples: dict
              dictioanry of PESummary.utils.array.Array objects containing the
              samples corresponding to parameter for each mcmc chain
          preliminary: Bool, optional
              if True, add a preliminary watermark to the plot
          """
          filename = os.path.join(
              savedir, "{}_autocorrelation_{}.png".format(label, parameter)
          )
          if os.path.isfile(filename) and checkpoint:
              return
          same_samples = [val for key, val in samples.items()]
          fig = core._autocorrelation_plot_mcmc(parameter, same_samples)
          _PlotGeneration.save(
              fig, filename, preliminary=preliminary
          )
  
      def oned_cdf_plot(self, label):
          """Generate oned CDF plots for all parameters in the result file
  
          Parameters
          ----------
          label: str
              the label for the results file that you wish to plot
          """
          error_message = (
              "Failed to generate a CDF plot for %s because {}"
          )
          iterator, samples, function = self._mcmc_iterator(
              label, "_oned_cdf_plot"
          )
          arguments = [
              (
                  [
                      self.savedir, label, param, samples[param],
                      latex_labels[param], self.preliminary_pages[label],
                      self.checkpoint
                  ], function, error_message % (param)
              ) for param in iterator
          ]
          self.pool.starmap(self._try_to_make_a_plot, arguments)
  
      @staticmethod
      def _oned_cdf_plot(
          savedir, label, parameter, samples, latex_label, preliminary=False,
          checkpoint=False
      ):
          """Generate a oned CDF plot for a given set of samples
  
          Parameters
          ----------
          savedir: str
              the directory you wish to save the plot in
          label: str
              the label corresponding to the results file
          parameter: str
              the name of the parameter that you wish to plot
          samples: PESummary.utils.array.Array
              array containing the samples corresponding to parameter
          latex_label: str
              the latex label corresponding to parameter
          preliminary: Bool, optional
              if True, add a preliminary watermark to the plot
          """
          filename = os.path.join(
              savedir + "{}_cdf_{}.png".format(label, parameter)
          )
          if os.path.isfile(filename) and checkpoint:
              return
          fig = core._1d_cdf_plot(parameter, samples, latex_label)
          _PlotGeneration.save(
              fig, filename, preliminary=preliminary
          )
  
      @staticmethod
      def _oned_cdf_plot_mcmc(
          savedir, label, parameter, samples, latex_label, preliminary=False,
          checkpoint=False
      ):
          """Generate a oned CDF plot for a given set of samples, one for each
          mcmc chain
  
          Parameters
          ----------
          savedir: str
              the directory you wish to save the plot in
          label: str
              the label corresponding to the results file
          parameter: str
              the name of the parameter that you wish to plot
          samples: dict
              dictionary of PESummary.utils.array.Array objects containing the
              samples corresponding to parameter for each mcmc chain
          latex_label: str
              the latex label corresponding to parameter
          preliminary: Bool, optional
              if True, add a preliminary watermark to the plot
          """
          filename = os.path.join(
              savedir + "{}_cdf_{}.png".format(label, parameter)
          )
          if os.path.isfile(filename) and checkpoint:
              return
          same_samples = [val for key, val in samples.items()]
          fig = core._1d_cdf_plot_mcmc(parameter, same_samples, latex_label)
          _PlotGeneration.save(
              fig, filename, preliminary=preliminary
          )
  
      def interactive_ridgeline_plot(self, label):
          """Generate an interactive ridgeline plot for all paramaters that are
          common to all result files
          """
          error_message = (
              "Failed to generate an interactive ridgeline plot for %s because {}"
          )
          for param in self.same_parameters:
              arguments = [
                  self.savedir, param, self.same_samples[param],
                  latex_labels[param], self.colors, self.checkpoint
              ]
              self._try_to_make_a_plot(
                  arguments, self._interactive_ridgeline_plot,
                  error_message % (param)
              )
              continue
  
      @staticmethod
      def _interactive_ridgeline_plot(
          savedir, parameter, samples, latex_label, colors, checkpoint=False
      ):
          """Generate an interactive ridgeline plot for
          """
          filename = os.path.join(
              savedir, "interactive_ridgeline_{}.html".format(parameter)
          )
          if os.path.isfile(filename) and checkpoint:
              return
          same_samples = [val for key, val in samples.items()]
          _ = interactive.ridgeline(
              same_samples, list(samples.keys()), xlabel=latex_label,
              colors=colors, write_to_html_file=filename
          )
  
      def interactive_corner_plot(self, label):
          """Generate an interactive corner plot for a given result file
  
          Parameters
          ----------
          label: str
              the label for the results file that you wish to plot
          """
          self._interactive_corner_plot(
              self.savedir, label, self.samples[label], latex_labels,
              self.checkpoint
          )
  
      @staticmethod
      def _interactive_corner_plot(
          savedir, label, samples, latex_labels, checkpoint=False
      ):
          """Generate an interactive corner plot for a given set of samples
  
          Parameters
          ----------
          savedir: str
              the directory you wish to save the plot in
          label: str
              the label corresponding to the results file
          samples: dict
              dictionary containing PESummary.utils.array.Array objects that
              contain samples for each parameter
          latex_labels: str
              latex labels for each parameter in samples
          """
          filename = os.path.join(
              savedir, "corner", "{}_interactive.html".format(label)
          )
          if os.path.isfile(filename) and checkpoint:
              return
          parameters = samples.keys()
          data = [samples[parameter] for parameter in parameters]
          latex_labels = [latex_labels[parameter] for parameter in parameters]
          _ = interactive.corner(
              data, latex_labels, write_to_html_file=filename
          )
  
      def oned_cdf_comparison_plot(self, label):
          """Generate oned comparison CDF plots for all parameters that are
          common to all result files
  
          Parameters
          ----------
          label: str
              the label for the results file that you wish to plot
          """
          error_message = (
              "Failed to generate a comparison CDF plot for %s because {}"
          )
          for param in self.same_parameters:
              arguments = [
                  self.savedir, param, self.same_samples[param],
                  latex_labels[param], self.colors, self.linestyles,
                  self.preliminary_comparison_pages, self.checkpoint
              ]
              self._try_to_make_a_plot(
                  arguments, self._oned_cdf_comparison_plot,
                  error_message % (param)
              )
              continue
  
      @staticmethod
      def _oned_cdf_comparison_plot(
          savedir, parameter, samples, latex_label, colors, linestyles=None,
          preliminary=False, checkpoint=False
      ):
          """Generate a oned comparison CDF plot for a given parameter
  
          Parameters
          ----------
          savedir: str
              the directory you wish to save the plot in
          parameter: str
              the name of the parameter that you wish to make a oned comparison
              histogram for
          samples: dict
              dictionary of pesummary.utils.array.Array objects containing the
              samples that correspond to parameter for each result file. The key
              should be the corresponding label
          latex_label: str
              the latex label for parameter
          colors: list
              list of colors to be used to distinguish different result files
          linestyles: list, optional
              list of linestyles used to distinguish different result files
          preliminary: Bool, optional
              if True, add a preliminary watermark to the plot
          """
          filename = os.path.join(
              savedir, "combined_cdf_{}.png".format(parameter)
          )
          if os.path.isfile(filename) and checkpoint:
              return
          keys = list(samples.keys())
          same_samples = [samples[key] for key in keys]
          fig = core._1d_cdf_comparison_plot(
              parameter, same_samples, colors, latex_label, keys, linestyles
          )
          _PlotGeneration.save(
              fig, filename, preliminary=preliminary
          )
  
      def box_plot_comparison_plot(self, label):
          """Generate comparison box plots for all parameters that are
          common to all result files
  
          Parameters
          ----------
          label: str
              the label for the results file that you wish to plot
          """
          error_message = (
              "Failed to generate a comparison box plot for %s because {}"
          )
          for param in self.same_parameters:
              arguments = [
                  self.savedir, param, self.same_samples[param],
                  latex_labels[param], self.colors,
                  self.preliminary_comparison_pages, self.checkpoint
              ]
              self._try_to_make_a_plot(
                  arguments, self._box_plot_comparison_plot,
                  error_message % (param)
              )
              continue
  
      @staticmethod
      def _box_plot_comparison_plot(
          savedir, parameter, samples, latex_label, colors, preliminary=False,
          checkpoint=False
      ):
          """Generate a comparison box plot for a given parameter
  
          Parameters
          ----------
          savedir: str
              the directory you wish to save the plot in
          parameter: str
              the name of the parameter that you wish to make a oned comparison
              histogram for
          samples: dict
              dictionary of pesummary.utils.array.Array objects containing the
              samples that correspond to parameter for each result file. The key
              should be the corresponding label
          latex_label: str
              the latex label for parameter
          colors: list
              list of colors to be used to distinguish different result files
          preliminary: Bool, optional
              if True, add a preliminary watermark to the plot
          """
          filename = os.path.join(
              savedir, "combined_boxplot_{}.png".format(parameter)
          )
          if os.path.isfile(filename) and checkpoint:
              return
          same_samples = [val for key, val in samples.items()]
          fig = core._comparison_box_plot(
              parameter, same_samples, colors, latex_label,
              list(samples.keys())
          )
          _PlotGeneration.save(
              fig, filename, preliminary=preliminary
          )
  
      def custom_plot(self, label):
          """Generate custom plots according to the passed python file
  
          Parameters
          ----------
          label: str
              the label for the results file that you wish to plot
          """
          import importlib
  
          if self.custom_plotting[0] != "":
              import sys
  
              sys.path.append(self.custom_plotting[0])
          mod = importlib.import_module(self.custom_plotting[1])
  
          methods = [getattr(mod, i) for i in mod.__single_plots__]
          for num, i in enumerate(methods):
              fig = i(
                  list(self.samples[label].keys()), self.samples[label]
              )
              _PlotGeneration.save(
                  fig, os.path.join(
                      self.savedir, "{}_custom_plotting_{}".format(label, num)
                  ), preliminary=self.preliminary_pages[label]
              )
  