diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 4d0343f47985fc802d4dc855f63ac40dd2b5bd9a..a063d51d06ccbbc4d10fd602c7c11a1f40f30bcd 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -43,7 +43,7 @@ basic-3.7:
# test example on python 3.7
python-3.7:
stage: test
- image: bilbydev/v2-dockerfile-test-suite-python37
+ image: quay.io/gregory_ashton/bilby_v2-dockerfile-test-suite-python37-frozen
script:
- python -m pip install .
@@ -69,7 +69,7 @@ python-3.7:
# test example on python 3.8
python-3.8:
stage: test
- image: bilbydev/v2-dockerfile-test-suite-python38
+ image: quay.io/gregory_ashton/bilby_v2-dockerfile-test-suite-python38-frozen
script:
- python -m pip install .
@@ -78,7 +78,7 @@ python-3.8:
# test example on python 3.6
python-3.6:
stage: test
- image: bilbydev/v2-dockerfile-test-suite-python36
+ image: quay.io/gregory_ashton/bilby_v2-dockerfile-test-suite-python36-frozen
script:
- python -m pip install .
@@ -87,7 +87,7 @@ python-3.6:
# test samplers on python 3.7
python-3.7-samplers:
stage: test
- image: bilbydev/v2-dockerfile-test-suite-python37
+ image: quay.io/gregory_ashton/bilby_v2-dockerfile-test-suite-python37-frozen
script:
- python -m pip install .
@@ -97,7 +97,7 @@ python-3.7-samplers:
# test samplers on python 3.6
python-3.6-samplers:
stage: test
- image: bilbydev/v2-dockerfile-test-suite-python36
+ image: quay.io/gregory_ashton/bilby_v2-dockerfile-test-suite-python36-frozen
script:
- python -m pip install .
@@ -106,7 +106,7 @@ python-3.6-samplers:
# Test containers are up to date
containers:
stage: test
- image: bilbydev/v2-dockerfile-test-suite-python37
+ image: quay.io/gregory_ashton/bilby_v2-dockerfile-test-suite-python37-frozen
script:
- cd containers
- python write_dockerfiles.py
@@ -117,7 +117,7 @@ containers:
# Tests run at a fixed schedule rather than on push
scheduled-python-3.7:
stage: test
- image: bilbydev/v2-dockerfile-test-suite-python37
+ image: quay.io/gregory_ashton/bilby_v2-dockerfile-test-suite-python37-frozen
only:
- schedules
script:
@@ -129,7 +129,7 @@ scheduled-python-3.7:
plotting:
stage: test
- image: bilbydev/bilby-test-suite-python37
+ image: quay.io/gregory_ashton/bilby_v2-dockerfile-test-suite-python37-frozen
only:
- schedules
script:
@@ -138,6 +138,12 @@ plotting:
- pytest test/gw/plot_test.py
+authors:
+ stage: test
+ image: quay.io/gregory_ashton/bilby_v2-dockerfile-test-suite-python37-frozen
+ script:
+ - python test/check_author_list.py
+
pages:
stage: deploy
dependencies:
@@ -156,7 +162,7 @@ pages:
deploy_release:
stage: deploy
- image: bilbydev/v2-dockerfile-test-suite-python37
+ image: quay.io/gregory_ashton/bilby_v2-dockerfile-test-suite-python37-frozen
variables:
TWINE_USERNAME: $PYPI_USERNAME
TWINE_PASSWORD: $PYPI_PASSWORD
@@ -171,7 +177,7 @@ deploy_release:
precommits-py3.7:
stage: test
- image: bilbydev/v2-dockerfile-test-suite-python37
+ image: quay.io/gregory_ashton/bilby_v2-dockerfile-test-suite-python37-frozen
script:
- source activate python37
- mkdir -p .pip37
diff --git a/AUTHORS.md b/AUTHORS.md
new file mode 100644
index 0000000000000000000000000000000000000000..bfd80a6e9bf73780d29bc0a133324434cd4eba1c
--- /dev/null
+++ b/AUTHORS.md
@@ -0,0 +1,71 @@
+# Authors
+
+This file lists all the authors in first-name alphabetical order who have
+contributed (either by code contribution or indirectly). If your name is not
+listed here, please contact anyone on this list and raise your concern.
+
+Abhirup Ghosh
+Aditya Vijaykumar
+Andrew Kim
+Andrew Miller
+Antoni Ramos-Buades
+Avi Vajpeyi
+Bruce Edelman
+Carl-Johan Haster
+Cecilio Garcia-Quiros
+Charlie Hoy
+Christopher Berry
+Christos Karathanasis
+Colm Talbot
+Daniel Williams
+David Keitel
+Duncan Macleod
+Eric Thrane
+Ethan Payne
+Francisco Javier Hernandez
+Gregory Ashton
+Hector Estelles
+Ignacio Magaña Hernandez
+Isobel Marguarethe Romero-Shaw
+Jade Powell
+James A Clark
+John Veitch
+Katerina Chatziioannou
+Kaylee de Soto
+Khun Sang Phukon
+Kshipraa Athar
+Liting Xiao
+Maite Mateu-Lucena
+Marc Arene
+Marcus Edward Lower
+Margaret Millhouse
+Marta Colleoni
+Matthew Carney
+Matthew David Pitkin
+Michael Puerrer
+Michael Williams
+Monica Rizzo
+Moritz Huebner
+Nicola De Lillo
+Nikhil Sarin
+Nirban Bose
+Paul Easter
+Paul Lasky
+Philip Relton
+Rhys Green
+Roberto Cotesta
+Rory Smith
+S. H. Oh
+Sacha Husa
+Scott Coughlin
+Serguei Ossokine
+Shanika Galaudage
+Sharan Banagiri
+Shichao Wu
+Simon Stevenson
+Soichiro Morisaki
+Sumeet Kulkarni
+Sylvia Biscoveanu
+Tathagata Ghosh
+Virginia d'Emilio
+Vivien Raymond
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 63966fa169c26dfe44d2db723498c364ea037c6b..ddbd703b36f04a438a61bcc14338310d13c0ef43 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,33 @@
# All notable changes will be documented in this file
+## [1.0.3] 2020-11-23
+Version 1.0.4 release of bilby
+
+### Added
+- Added a chirp-mass and mass-ratio prior which are uniform in component masses (!891)
+
+### Changes
+- Fixed issue in the CI
+
+## [1.0.3] 2020-10-23
+
+Version 1.0.3 release of bilby
+
+### Added
+- SlabSpikePrior and examples (!857)
+- Authors file (!885)
+- CDF function to conditional priors (!882)
+- Waveform plot in visualising_the_results.ipynb (!817)
+- Addition of dnest4 sampler (!849, !883)
+- Loaded modules added to meta-data (!881)
+
+### Changes
+- Constraint to Uniform priors in ROQ tutorial (!884)
+- Fix to CDF and PDF for SymmetricLogUniform prior (!876)
+- Fix bug in evidence combination (!880)
+- Typo fixes (!878, !887, !879)
+- Minor bug fixes (!888)
+
## [1.0.2] 2020-09-14
Version 1.0.2 release of bilby
@@ -8,7 +36,7 @@ Version 1.0.2 release of bilby
- Template for the docker files (!783)
- New delta_phase parameter (!850)
- Normalization factor to time-domain waveform plot (!867)
-- JSON encoding for int and float types (!866)
+- JSON encoding for int and float types (!866)
- Various minor formatting additions (!870)
### Changes
diff --git a/bilby/core/prior/__init__.py b/bilby/core/prior/__init__.py
index 253ad6c9c75ad0a644d5f674f4c408ffca538de0..fc795c3e1f1f69fbcd2b52d994b8c17d752f6e31 100644
--- a/bilby/core/prior/__init__.py
+++ b/bilby/core/prior/__init__.py
@@ -4,3 +4,4 @@ from .conditional import *
from .dict import *
from .interpolated import *
from .joint import *
+from .slabspike import *
diff --git a/bilby/core/prior/analytical.py b/bilby/core/prior/analytical.py
index b575b3376e99a5185dfba1b01fd5de174a87b6de..7a7fb2b6b5c59b5be7178e60172c889a0b20d380 100644
--- a/bilby/core/prior/analytical.py
+++ b/bilby/core/prior/analytical.py
@@ -618,6 +618,7 @@ class TruncatedGaussian(Prior):
/ self.sigma / self.normalisation * self.is_in_prior_range(val)
def cdf(self, val):
+ val = np.atleast_1d(val)
_cdf = (erf((val - self.mu) / 2 ** 0.5 / self.sigma) - erf(
(self.minimum - self.mu) / 2 ** 0.5 / self.sigma)) / 2 / self.normalisation
_cdf[val > self.maximum] = 1
diff --git a/bilby/core/prior/conditional.py b/bilby/core/prior/conditional.py
index c96c1a05da9b4e9aee7f2159b868c5e1fd1f7ded..80cdbb91acfb3a49342aad479ef8881c27cca71d 100644
--- a/bilby/core/prior/conditional.py
+++ b/bilby/core/prior/conditional.py
@@ -110,9 +110,41 @@ def conditional_prior_factory(prior_class):
return super(ConditionalPrior, self).prob(val)
def ln_prob(self, val, **required_variables):
+ """Return the natural log prior probability of val.
+
+ Parameters
+ ----------
+ val: Union[float, int, array_like]
+ See superclass
+ required_variables:
+ Any required variables that this prior depends on
+
+
+ Returns
+ -------
+ float: Natural log prior probability of val
+ """
self.update_conditions(**required_variables)
return super(ConditionalPrior, self).ln_prob(val)
+ def cdf(self, val, **required_variables):
+ """Return the cdf of val.
+
+ Parameters
+ ----------
+ val: Union[float, int, array_like]
+ See superclass
+ required_variables:
+ Any required variables that this prior depends on
+
+
+ Returns
+ -------
+ float: CDF of val
+ """
+ self.update_conditions(**required_variables)
+ return super(ConditionalPrior, self).cdf(val)
+
def update_conditions(self, **required_variables):
"""
This method updates the conditional parameters (depending on the parent class
diff --git a/bilby/core/prior/slabspike.py b/bilby/core/prior/slabspike.py
new file mode 100644
index 0000000000000000000000000000000000000000..de7dc48ad5ae0004a38ec538a4acb82673b57753
--- /dev/null
+++ b/bilby/core/prior/slabspike.py
@@ -0,0 +1,169 @@
+import numpy as np
+
+from bilby.core.prior.base import Prior
+from bilby.core.utils import logger
+
+
+class SlabSpikePrior(Prior):
+
+ def __init__(self, slab, spike_location=None, spike_height=0):
+ """'Slab-and-spike' prior, see e.g. https://arxiv.org/abs/1812.07259
+ This prior is composed of a `slab`, i.e. any common prior distribution,
+ and a Dirac spike at a fixed location. This can effectively be used
+ to emulate sampling in the number of dimensions (similar to reversible-
+ jump MCMC).
+
+ `SymmetricLogUniform` and `FermiDirac` are currently not supported.
+
+ Parameters
+ ----------
+ slab: Prior
+ Any instance of a bilby prior class. All general prior attributes
+ from the slab are copied into the SlabSpikePrior.
+ Note that this hasn't been tested for conditional priors.
+ spike_location: float, optional
+ Location of the Dirac spike. Must be between minimum and maximum
+ of the slab. Defaults to the minimum of the slab
+ spike_height: float, optional
+ Relative weight of the spike compared to the slab. Must be
+ between 0 and 1. Defaults to 0, i.e. the prior is just the slab.
+
+ """
+ self.slab = slab
+ super().__init__(name=self.slab.name, latex_label=self.slab.latex_label, unit=self.slab.unit,
+ minimum=self.slab.minimum, maximum=self.slab.maximum,
+ check_range_nonzero=self.slab.check_range_nonzero, boundary=self.slab.boundary)
+ self.spike_location = spike_location
+ self.spike_height = spike_height
+ try:
+ self.inverse_cdf_below_spike = self._find_inverse_cdf_fraction_before_spike()
+ except Exception as e:
+ logger.warning("Disregard the following warning when running tests:\n {}".format(e))
+
+ @property
+ def spike_location(self):
+ return self._spike_loc
+
+ @spike_location.setter
+ def spike_location(self, spike_loc):
+ if spike_loc is None:
+ spike_loc = self.minimum
+ if not self.minimum <= spike_loc <= self.maximum:
+ raise ValueError("Spike location {} not within prior domain ".format(spike_loc))
+ self._spike_loc = spike_loc
+
+ @property
+ def spike_height(self):
+ return self._spike_height
+
+ @spike_height.setter
+ def spike_height(self, spike_height):
+ if 0 <= spike_height <= 1:
+ self._spike_height = spike_height
+ else:
+ raise ValueError("Spike height must be between 0 and 1, but is {}".format(spike_height))
+
+ @property
+ def slab_fraction(self):
+ """ Relative prior weight of the slab. """
+ return 1 - self.spike_height
+
+ def _find_inverse_cdf_fraction_before_spike(self):
+ return float(self.slab.cdf(self.spike_location)) * self.slab_fraction
+
+ def rescale(self, val):
+ """
+ 'Rescale' a sample from the unit line element to the prior.
+
+ Parameters
+ ----------
+ val: Union[float, int, array_like]
+ A random number between 0 and 1
+
+ Returns
+ -------
+ array_like: Associated prior value with input value.
+ """
+ val = np.atleast_1d(val)
+
+ lower_indices = np.where(val < self.inverse_cdf_below_spike)[0]
+ intermediate_indices = np.where(np.logical_and(
+ self.inverse_cdf_below_spike <= val,
+ val <= self.inverse_cdf_below_spike + self.spike_height))[0]
+ higher_indices = np.where(val > self.inverse_cdf_below_spike + self.spike_height)[0]
+
+ res = np.zeros(len(val))
+ res[lower_indices] = self._contracted_rescale(val[lower_indices])
+ res[intermediate_indices] = self.spike_location
+ res[higher_indices] = self._contracted_rescale(val[higher_indices] - self.spike_height)
+ return res
+
+ def _contracted_rescale(self, val):
+ """
+ Contracted version of the rescale function that implements the `rescale` function
+ on the pure slab part of the prior.
+
+ Parameters
+ ----------
+ val: Union[float, int, array_like]
+ A random number between 0 and self.slab_fraction
+
+ Returns
+ -------
+ array_like: Associated prior value with input value.
+ """
+ return self.slab.rescale(val / self.slab_fraction)
+
+ def prob(self, val):
+ """Return the prior probability of val.
+ Returns np.inf for the spike location
+
+ Parameters
+ ----------
+ val: Union[float, int, array_like]
+
+ Returns
+ -------
+ array_like: Prior probability of val
+ """
+ res = self.slab.prob(val) * self.slab_fraction
+ res = np.atleast_1d(res)
+ res[np.where(val == self.spike_location)] = np.inf
+ return res
+
+ def ln_prob(self, val):
+ """Return the Log prior probability of val.
+ Returns np.inf for the spike location
+
+ Parameters
+ ----------
+ val: Union[float, int, array_like]
+
+ Returns
+ -------
+ array_like: Prior probability of val
+ """
+ res = self.slab.ln_prob(val) + np.log(self.slab_fraction)
+ res = np.atleast_1d(res)
+ res[np.where(val == self.spike_location)] = np.inf
+ return res
+
+ def cdf(self, val):
+ """ Return the CDF of the prior.
+ This calls to the slab CDF and adds a discrete step
+ at the spike location.
+
+ Parameters
+ ----------
+ val: Union[float, int, array_like]
+
+ Returns
+ -------
+ array_like: CDF value of val
+
+ """
+ res = self.slab.cdf(val) * self.slab_fraction
+ res = np.atleast_1d(res)
+ indices_above_spike = np.where(val > self.spike_location)[0]
+ res[indices_above_spike] += self.spike_height
+ return res
diff --git a/bilby/core/sampler/__init__.py b/bilby/core/sampler/__init__.py
index 6d02882f67f2749e98266cb96bf9a95cf5864828..27da24334e8839da74ac1ae0fcb2d577ff99bc08 100644
--- a/bilby/core/sampler/__init__.py
+++ b/bilby/core/sampler/__init__.py
@@ -25,11 +25,11 @@ from .dnest4 import DNest4
from . import proposal
IMPLEMENTED_SAMPLERS = {
- 'cpnest': Cpnest, 'dynamic_dynesty': DynamicDynesty, 'dynesty': Dynesty,
- 'emcee': Emcee, 'kombine': Kombine, 'nestle': Nestle, 'ptemcee': Ptemcee,
- 'ptmcmcsampler': PTMCMCSampler, 'pymc3': Pymc3, 'pymultinest': Pymultinest,
- 'pypolychord': PyPolyChord, 'ultranest': Ultranest,
- 'fake_sampler': FakeSampler, 'dnest4': DNest4}
+ 'cpnest': Cpnest, 'dnest4': DNest4, 'dynamic_dynesty': DynamicDynesty,
+ 'dynesty': Dynesty, 'emcee': Emcee, 'kombine': Kombine, 'nestle': Nestle,
+ 'ptemcee': Ptemcee, 'ptmcmcsampler': PTMCMCSampler, 'pymc3': Pymc3,
+ 'pymultinest': Pymultinest, 'pypolychord': PyPolyChord, 'ultranest': Ultranest,
+ 'fake_sampler': FakeSampler}
if command_line_args.sampler_help:
sampler = command_line_args.sampler_help
diff --git a/bilby/core/sampler/base_sampler.py b/bilby/core/sampler/base_sampler.py
index 74e880fbb852ac48ecde433bcbc0d54de2115b5d..fa05b4f83adbe59ff5c8444fc8d43f5ab26d722a 100644
--- a/bilby/core/sampler/base_sampler.py
+++ b/bilby/core/sampler/base_sampler.py
@@ -1,10 +1,13 @@
from __future__ import absolute_import
import datetime
+import distutils.dir_util
import numpy as np
+import os
+import tempfile
from pandas import DataFrame
-from ..utils import logger, command_line_args, Counter
+from ..utils import logger, check_directory_exists_and_if_not_mkdir, command_line_args, Counter
from ..prior import Prior, PriorDict, DeltaFunction, Constraint
from ..result import Result, read_in_result
@@ -541,7 +544,8 @@ class Sampler(object):
class NestedSampler(Sampler):
- npoints_equiv_kwargs = ['nlive', 'nlives', 'n_live_points', 'npoints', 'npoint', 'Nlive', 'num_live_points']
+ npoints_equiv_kwargs = ['nlive', 'nlives', 'n_live_points', 'npoints',
+ 'npoint', 'Nlive', 'num_live_points', 'num_particles']
walks_equiv_kwargs = ['walks', 'steps', 'nmcmc']
def reorder_loglikelihoods(self, unsorted_loglikelihoods, unsorted_samples,
@@ -601,6 +605,27 @@ class NestedSampler(Sampler):
else:
return np.nan_to_num(-np.inf)
+ def _setup_run_directory(self):
+ """
+ If using a temporary directory, the output directory is moved to the
+ temporary directory.
+ Used for Dnest4, Pymultinest, and Ultranest.
+ """
+ if self.use_temporary_directory:
+ temporary_outputfiles_basename = tempfile.TemporaryDirectory().name
+ self.temporary_outputfiles_basename = temporary_outputfiles_basename
+
+ if os.path.exists(self.outputfiles_basename):
+ distutils.dir_util.copy_tree(self.outputfiles_basename, self.temporary_outputfiles_basename)
+ check_directory_exists_and_if_not_mkdir(temporary_outputfiles_basename)
+
+ self.kwargs["outputfiles_basename"] = self.temporary_outputfiles_basename
+ logger.info("Using temporary file {}".format(temporary_outputfiles_basename))
+ else:
+ check_directory_exists_and_if_not_mkdir(self.outputfiles_basename)
+ self.kwargs["outputfiles_basename"] = self.outputfiles_basename
+ logger.info("Using output file {}".format(self.outputfiles_basename))
+
class MCMCSampler(Sampler):
nwalkers_equiv_kwargs = ['nwalker', 'nwalkers', 'draws', 'Niter']
diff --git a/bilby/core/sampler/cpnest.py b/bilby/core/sampler/cpnest.py
index 611219e76708e7cae9f9bae073d7c44d95e5b480..25183bd07eb53938b122bb0305b89b0c548d718d 100644
--- a/bilby/core/sampler/cpnest.py
+++ b/bilby/core/sampler/cpnest.py
@@ -1,5 +1,6 @@
from __future__ import absolute_import
+import array
import copy
import numpy as np
@@ -88,8 +89,8 @@ class Cpnest(NestedSampler):
prior_samples = self.priors.sample()
self._update_bounds()
point = LivePoint(
- self.names, [prior_samples[name]
- for name in self.names])
+ self.names, array.array(
+ 'f', [prior_samples[name] for name in self.names]))
return point
self._resolve_proposal_functions()
diff --git a/bilby/core/sampler/dnest4.py b/bilby/core/sampler/dnest4.py
index a623635fd6807d4e7d43c330b8f39a6648af3604..a35f54f6704c2101cd13d964ea9b6b689519e271 100644
--- a/bilby/core/sampler/dnest4.py
+++ b/bilby/core/sampler/dnest4.py
@@ -1,12 +1,10 @@
-from __future__ import absolute_import
-
import os
-import tempfile
import shutil
import distutils.dir_util
import signal
import time
import datetime
+import sys
import numpy as np
import pandas as pd
@@ -20,14 +18,14 @@ class _DNest4Model(object):
def __init__(self, log_likelihood_func, from_prior_func, widths, centers, highs, lows):
"""Initialize the DNest4 model.
Args:
- log_likelihood_func (function): The loglikelihood function to use
- during the Nested Sampling run.
- from_prior_func (function): The function to use when randomly
- selecting parameter vectors from the prior space.
- widths (numpy.array): The approximate widths of the prior
- distrbutions.
- centers (numpy.array): The approximate center points of the prior
- distributions.
+ log_likelihood_func: function
+ The loglikelihood function to use during the Nested Sampling run.
+ from_prior_func: function
+ The function to use when randomly selecting parameter vectors from the prior space.
+ widths: array_like
+ The approximate widths of the prior distrbutions.
+ centers: array_like
+ The approximate center points of the prior distributions.
"""
self._log_likelihood = log_likelihood_func
self._from_prior = from_prior_func
@@ -58,9 +56,11 @@ class _DNest4Model(object):
return 0.0
- def wrap(self, x, a, b):
- assert b > a
- return (x - a) % (b - a) + a
+ @staticmethod
+ def wrap(x, minimum, maximum):
+ if maximum <= minimum:
+ raise ValueError("maximum {} <= minimum {}, when trying to wrap coordinates".format(maximum, minimum))
+ return (x - minimum) % (maximum - minimum) + minimum
class DNest4(NestedSampler):
@@ -83,8 +83,9 @@ class DNest4(NestedSampler):
The python DNest4 backend for storing the output.
Options are: 'memory' and 'csv'. If 'memory' the
DNest4 outputs are stored in memory during the run. If 'csv' the
- DNest4 outputs are written out to filse with a CSV format during
+ DNest4 outputs are written out to files with a CSV format during
the run.
+ CSV backend may not be functional right now (October 2020)
num_steps: int
The number of MCMC iterations to run
new_level_interval: int
@@ -97,53 +98,20 @@ class DNest4(NestedSampler):
Set the seed for the C++ random number generator
verbose: Bool
If True, prints information during run
- TO DO: add equivalent args for num_particles (nlive, etc.)
- Add sampling time functions
"""
- default_kwargs = dict(
- max_num_levels=20,
- num_steps=500, # Number of iterations
- new_level_interval=10000,
- num_per_step=10000,
- thread_steps=1,
- num_particles=1000,
- lam=10.0,
- beta=100,
- seed=None,
- verbose=True,
- outputfiles_basename=None,
- # backend_callback=None, # for checkpointing in dnest5
- backend='memory', # csv is currently bugged right now
-
- # could change max_num_levels based on snr
- )
-
- def __init__(
- self,
- likelihood,
- priors,
- outdir="outdir",
- label="label",
- use_ratio=False,
- plot=False,
- exit_code=77,
- skip_import_verification=False,
- temporary_directory=True,
- resume=True,
- **kwargs
- ):
+ default_kwargs = dict(max_num_levels=20, num_steps=500,
+ new_level_interval=10000, num_per_step=10000,
+ thread_steps=1, num_particles=1000, lam=10.0,
+ beta=100, seed=None, verbose=True, outputfiles_basename=None,
+ backend='memory')
+
+ def __init__(self, likelihood, priors, outdir="outdir", label="label", use_ratio=False, plot=False,
+ exit_code=77, skip_import_verification=False, temporary_directory=True, **kwargs):
super(DNest4, self).__init__(
- likelihood=likelihood,
- priors=priors,
- outdir=outdir,
- label=label,
- use_ratio=use_ratio,
- plot=plot,
- skip_import_verification=skip_import_verification,
- exit_code=exit_code,
- **kwargs
- )
+ likelihood=likelihood, priors=priors, outdir=outdir, label=label,
+ use_ratio=use_ratio, plot=plot, skip_import_verification=skip_import_verification,
+ exit_code=exit_code, **kwargs)
self.num_particles = self.kwargs["num_particles"]
self.max_num_levels = self.kwargs["max_num_levels"]
@@ -151,6 +119,13 @@ class DNest4(NestedSampler):
self._backend = self.kwargs["backend"]
self.use_temporary_directory = temporary_directory
+ self.start_time = np.nan
+ self.sampler = None
+ self._information = np.nan
+ self._last_live_sample_info = np.nan
+ self._outputfiles_basename = None
+ self._temporary_outputfiles_basename = None
+
signal.signal(signal.SIGTERM, self.write_current_state_and_exit)
signal.signal(signal.SIGINT, self.write_current_state_and_exit)
signal.signal(signal.SIGALRM, self.write_current_state_and_exit)
@@ -180,26 +155,19 @@ class DNest4(NestedSampler):
self._highs = np.array(highs)
self._lows = np.array(lows)
- self._from_prior = self.get_random_draw_from_prior
-
- self._dnest4_model = _DNest4Model(self.log_likelihood, self._from_prior, self._widths,
+ self._dnest4_model = _DNest4Model(self.log_likelihood, self.get_random_draw_from_prior, self._widths,
self._centers, self._highs, self._lows)
def _set_backend(self):
import dnest4
if self._backend == 'csv':
- # for CSVBackend, which is output data to disk
- backend = dnest4.backends.CSVBackend("{}/dnest4{}/".format(self.outdir, self.label), sep=" ")
- # change to original
+ return dnest4.backends.CSVBackend("{}/dnest4{}/".format(self.outdir, self.label), sep=" ")
else:
- # for the MemoryBackend, which is output data to memory
- backend = dnest4.backends.MemoryBackend()
- return backend
+ return dnest4.backends.MemoryBackend()
def _set_dnest4_kwargs(self):
dnest4_keys = ["num_steps", "new_level_interval", "lam", "beta", "seed"]
self.dnest4_kwargs = {key: self.kwargs[key] for key in dnest4_keys}
- return self.dnest4_kwargs
def run_sampler(self):
import dnest4
@@ -233,17 +201,11 @@ class DNest4(NestedSampler):
if self._backend == 'memory':
self._last_live_sample_info = pd.DataFrame(self.sampler.backend.sample_info[-1])
self.result.log_likelihood_evaluations = self._last_live_sample_info['log_likelihood']
-
self.result.samples = np.array(self.sampler.backend.posterior_samples)
- print("here")
- print(self.sampler.backend.posterior_samples)
- print(self.result.samples)
else:
sample_info_path = './' + self.kwargs["outputfiles_basename"] + '/sample_info.txt'
-
sample_info = np.genfromtxt(sample_info_path, comments='#', names=True)
self.result.log_likelihood_evaluations = sample_info['log_likelihood']
-
self.result.samples = np.array(self.sampler.backend.posterior_samples)
self.result.sampler_output = out
@@ -262,36 +224,7 @@ class DNest4(NestedSampler):
def _verify_kwargs_against_default_kwargs(self):
self.outputfiles_basename = self.kwargs.pop("outputfiles_basename", None)
-
- # if self.kwargs['backend_callback'] is None:
- # self.kwargs['backend_callback'] = self._backend_callback
-
- NestedSampler._verify_kwargs_against_default_kwargs(self)
-
- # def _backend_callback(self, *args, **kwargs):
- # if self.use_temporary_directory:
- # self._copy_temporary_directory_contents_to_proper_path()
- # self._calculate_and_save_sampling_time()
-
- def _setup_run_directory(self):
- """
- If using a temporary directory, the output directory is moved to the
- temporary directory.
- """
- if self.use_temporary_directory:
- temporary_outputfiles_basename = tempfile.TemporaryDirectory().name
- self.temporary_outputfiles_basename = temporary_outputfiles_basename
-
- if os.path.exists(self.outputfiles_basename):
- distutils.dir_util.copy_tree(self.outputfiles_basename, self.temporary_outputfiles_basename)
- check_directory_exists_and_if_not_mkdir(temporary_outputfiles_basename)
-
- self.kwargs["outputfiles_basename"] = self.temporary_outputfiles_basename
- logger.info("Using temporary file {}".format(temporary_outputfiles_basename))
- else:
- check_directory_exists_and_if_not_mkdir(self.outputfiles_basename)
- self.kwargs["outputfiles_basename"] = self.outpuxtfiles_basename
- logger.info("Using output file {}".format(self.outputfiles_basename))
+ super(DNest4, self)._verify_kwargs_against_default_kwargs()
def _check_and_load_sampling_time_file(self):
self.time_file_path = self.kwargs["outputfiles_basename"] + '/sampling_time.dat'
@@ -355,7 +288,7 @@ class DNest4(NestedSampler):
self._calculate_and_save_sampling_time()
if self.use_temporary_directory:
self._move_temporary_directory_to_proper_path()
- os._exit(self.exit_code)
+ sys.exit(self.exit_code)
def _move_temporary_directory_to_proper_path(self):
"""
diff --git a/bilby/core/sampler/ptemcee.py b/bilby/core/sampler/ptemcee.py
index a45a4c0853e965ea2057f4b7172ce22547d0b7f3..82cfcf4acc23a1957fb61043f16ae89cc8017dd9 100644
--- a/bilby/core/sampler/ptemcee.py
+++ b/bilby/core/sampler/ptemcee.py
@@ -146,8 +146,8 @@ class Ptemcee(MCMCSampler):
resume=True,
nsamples=5000,
burn_in_nact=50,
- burn_in_fixed_discard=100,
- mean_logl_frac=0.001,
+ burn_in_fixed_discard=0,
+ mean_logl_frac=0.01,
thin_by_nact=0.5,
autocorr_tol=50,
autocorr_c=5,
@@ -498,6 +498,7 @@ class Ptemcee(MCMCSampler):
self.mean_log_likelihood,
frac=self.convergence_inputs.mean_logl_frac
)
+ logger.debug("Mean logl min it = {}".format(mean_logl_min_it))
# Calculate the maximum discard number
discard_max = np.max(
@@ -1039,7 +1040,7 @@ def plot_tau(
ax.set_xlabel("Iteration")
ax.set_ylabel(r"$\langle \tau \rangle$")
ax.legend()
-
+ fig.tight_layout()
fig.savefig("{}/{}_checkpoint_tau.png".format(outdir, label))
plt.close(fig)
diff --git a/bilby/core/sampler/pymultinest.py b/bilby/core/sampler/pymultinest.py
index eaa14ccef7ec2c570689e6d17f9f3e09f3cdfc07..e977dc153f0a2572297b5a8bb382b462372b1243 100644
--- a/bilby/core/sampler/pymultinest.py
+++ b/bilby/core/sampler/pymultinest.py
@@ -1,11 +1,11 @@
import importlib
import os
-import tempfile
import shutil
import distutils.dir_util
import signal
import time
import datetime
+import sys
import numpy as np
@@ -175,7 +175,7 @@ class Pymultinest(NestedSampler):
self._calculate_and_save_sampling_time()
if self.use_temporary_directory:
self._move_temporary_directory_to_proper_path()
- os._exit(self.exit_code)
+ sys.exit(self.exit_code)
def _copy_temporary_directory_contents_to_proper_path(self):
"""
@@ -239,26 +239,6 @@ class Pymultinest(NestedSampler):
self.result.sampling_time = datetime.timedelta(seconds=self.total_sampling_time)
return self.result
- def _setup_run_directory(self):
- """
- If using a temporary directory, the output directory is moved to the
- temporary directory.
- """
- if self.use_temporary_directory:
- temporary_outputfiles_basename = tempfile.TemporaryDirectory().name
- self.temporary_outputfiles_basename = temporary_outputfiles_basename
-
- if os.path.exists(self.outputfiles_basename):
- distutils.dir_util.copy_tree(self.outputfiles_basename, self.temporary_outputfiles_basename)
- check_directory_exists_and_if_not_mkdir(temporary_outputfiles_basename)
-
- self.kwargs["outputfiles_basename"] = self.temporary_outputfiles_basename
- logger.info("Using temporary file {}".format(temporary_outputfiles_basename))
- else:
- check_directory_exists_and_if_not_mkdir(self.outputfiles_basename)
- self.kwargs["outputfiles_basename"] = self.outputfiles_basename
- logger.info("Using output file {}".format(self.outputfiles_basename))
-
def _check_and_load_sampling_time_file(self):
self.time_file_path = self.kwargs["outputfiles_basename"] + '/sampling_time.dat'
if os.path.exists(self.time_file_path):
diff --git a/bilby/core/sampler/ultranest.py b/bilby/core/sampler/ultranest.py
index 82815557ce7581a00789036afd7067593eb4fcfc..fdae9a8e9c4393b857a58a27a8f075d2bc704d12 100644
--- a/bilby/core/sampler/ultranest.py
+++ b/bilby/core/sampler/ultranest.py
@@ -6,7 +6,6 @@ import inspect
import os
import shutil
import signal
-import tempfile
import time
import numpy as np
@@ -287,6 +286,7 @@ class Ultranest(NestedSampler):
stepsampler = self.kwargs.pop("step_sampler", None)
self._setup_run_directory()
+ self.kwargs["log_dir"] = self.kwargs.pop("outputfiles_basename")
self._check_and_load_sampling_time_file()
# use reactive nested sampler when no live points are given
@@ -326,30 +326,6 @@ class Ultranest(NestedSampler):
return self.result
- def _setup_run_directory(self):
- """
- If using a temporary directory, the output directory is moved to the
- temporary directory and symlinked back.
- """
- if self.use_temporary_directory:
- temporary_outputfiles_basename = tempfile.TemporaryDirectory().name
- self.temporary_outputfiles_basename = temporary_outputfiles_basename
-
- if os.path.exists(self.outputfiles_basename):
- distutils.dir_util.copy_tree(
- self.outputfiles_basename, self.temporary_outputfiles_basename
- )
- check_directory_exists_and_if_not_mkdir(temporary_outputfiles_basename)
-
- self.kwargs["log_dir"] = self.temporary_outputfiles_basename
- logger.info(
- "Using temporary file {}".format(temporary_outputfiles_basename)
- )
- else:
- check_directory_exists_and_if_not_mkdir(self.outputfiles_basename)
- self.kwargs["log_dir"] = self.outputfiles_basename
- logger.info("Using output file {}".format(self.outputfiles_basename))
-
def _clean_up_run_directory(self):
if self.use_temporary_directory:
self._move_temporary_directory_to_proper_path()
diff --git a/bilby/gw/prior.py b/bilby/gw/prior.py
index 7d1b37da3bf3c0f35000fc699f6c48cd85aa772e..3ffcfb193df6f34ed07deb9689def2adf444bb60 100644
--- a/bilby/gw/prior.py
+++ b/bilby/gw/prior.py
@@ -4,11 +4,13 @@ import copy
import numpy as np
from scipy.interpolate import InterpolatedUnivariateSpline, interp1d
from scipy.integrate import cumtrapz
+from scipy.special import hyp2f1
from scipy.stats import norm
from ..core.prior import (PriorDict, Uniform, Prior, DeltaFunction, Gaussian,
Interped, Constraint, conditional_prior_factory,
- BaseJointPriorDist, JointPrior, JointPriorDistError)
+ BaseJointPriorDist, JointPrior, JointPriorDistError,
+ PowerLaw)
from ..core.utils import infer_args_from_method, logger
from .conversion import (
convert_to_lal_binary_black_hole_parameters,
@@ -285,6 +287,93 @@ class UniformSourceFrame(Cosmological):
return zs, p_dz
+class UniformInComponentsChirpMass(PowerLaw):
+
+ def __init__(self, minimum, maximum, name='chirp_mass',
+ latex_label='$\mathcal{M}$', unit=None, boundary=None):
+ """
+ Prior distribution for chirp mass which is uniform in component masses.
+
+ This is useful when chirp mass and mass ratio are sampled while the
+ prior is uniform in component masses.
+
+ Parameters
+ ----------
+ minimum : float
+ The minimum of chirp mass
+ maximum : float
+ The maximum of chirp mass
+ name: see superclass
+ latex_label: see superclass
+ unit: see superclass
+ boundary: see superclass
+ """
+ super(UniformInComponentsChirpMass, self).__init__(
+ alpha=1., minimum=minimum, maximum=maximum,
+ name=name, latex_label=latex_label, unit=unit, boundary=boundary)
+
+
+class WrappedInterp1d(interp1d):
+ """ A wrapper around scipy interp1d which sets equality-by-instantiation """
+ def __eq__(self, other):
+
+ for key in self.__dict__:
+ if type(self.__dict__[key]) is np.ndarray:
+ if not np.array_equal(self.__dict__[key], other.__dict__[key]):
+ return False
+ elif key == "_spline":
+ pass
+ elif getattr(self, key) != getattr(other, key):
+ return False
+ return True
+
+
+class UniformInComponentsMassRatio(Prior):
+
+ def __init__(self, minimum, maximum, name='mass_ratio', latex_label='$q$',
+ unit=None, boundary=None):
+ """
+ Prior distribution for mass ratio which is uniform in component masses.
+
+ This is useful when chirp mass and mass ratio are sampled while the
+ prior is uniform in component masses.
+
+ Parameters
+ ----------
+ minimum : float
+ The minimum of mass ratio
+ maximum : float
+ The maximum of mass ratio
+ name: see superclass
+ latex_label: see superclass
+ unit: see superclass
+ boundary: see superclass
+ """
+ super(UniformInComponentsMassRatio, self).__init__(
+ minimum=minimum, maximum=maximum, name=name,
+ latex_label=latex_label, unit=unit, boundary=boundary)
+ self.norm = self._integral(maximum) - self._integral(minimum)
+ qs = np.linspace(minimum, maximum, 1000)
+ self.icdf = WrappedInterp1d(
+ self.cdf(qs), qs, kind='cubic',
+ bounds_error=False, fill_value=(minimum, maximum))
+
+ @staticmethod
+ def _integral(q):
+ return -5. * q**(-1. / 5.) * hyp2f1(-2. / 5., -1. / 5., 4. / 5., -q)
+
+ def cdf(self, val):
+ return (self._integral(val) - self._integral(self.minimum)) / self.norm
+
+ def rescale(self, val):
+ self.test_valid_for_rescaling(val)
+ return self.icdf(val)
+
+ def prob(self, val):
+ in_prior = (val >= self.minimum) & (val <= self.maximum)
+ return (1. + val)**(2. / 5.) / (val**(6. / 5.)) / self.norm * in_prior
+
+
class AlignedSpin(Interped):
def __init__(self, a_prior=Uniform(0, 1), z_prior=Uniform(-1, 1),
diff --git a/containers/dockerfile-template b/containers/dockerfile-template
index 46d4f54700cb9bfad245e7d1e3113b85589d73f4..eb2fa024cae7f1f93bdfa0d6ef256d6867538809 100644
--- a/containers/dockerfile-template
+++ b/containers/dockerfile-template
@@ -1,4 +1,4 @@
-FROM continuumio/miniconda3
+FROM containers.ligo.org/docker/base:conda
LABEL name="bilby Base miniconda3" \
maintainer="Gregory Ashton <gregory.ashton@ligo.org>"
diff --git a/containers/v2-dockerfile-test-suite-python35 b/containers/v2-dockerfile-test-suite-python35
index 38d4c8b2fcaebd5dc78e87cd699cc8419b69c1dc..544b562f37dc870538b71a4207139a90e8101c5d 100644
--- a/containers/v2-dockerfile-test-suite-python35
+++ b/containers/v2-dockerfile-test-suite-python35
@@ -1,6 +1,6 @@
# This dockerfile is written automatically and should not be modified by hand.
-FROM continuumio/miniconda3
+FROM containers.ligo.org/docker/base:conda
LABEL name="bilby Base miniconda3" \
maintainer="Gregory Ashton <gregory.ashton@ligo.org>"
diff --git a/containers/v2-dockerfile-test-suite-python36 b/containers/v2-dockerfile-test-suite-python36
index ae75fff03aa80026a56fa48bc7682f8acb852881..d9a2782cfb22c020520375665ff1668e7c5f6aa4 100644
--- a/containers/v2-dockerfile-test-suite-python36
+++ b/containers/v2-dockerfile-test-suite-python36
@@ -1,6 +1,6 @@
# This dockerfile is written automatically and should not be modified by hand.
-FROM continuumio/miniconda3
+FROM containers.ligo.org/docker/base:conda
LABEL name="bilby Base miniconda3" \
maintainer="Gregory Ashton <gregory.ashton@ligo.org>"
diff --git a/containers/v2-dockerfile-test-suite-python37 b/containers/v2-dockerfile-test-suite-python37
index 9e27fcab40ae8a7c0561a32b508449e0943925a6..b77f489227fd58720727a24d1a8989cc7b9dc36a 100644
--- a/containers/v2-dockerfile-test-suite-python37
+++ b/containers/v2-dockerfile-test-suite-python37
@@ -1,6 +1,6 @@
# This dockerfile is written automatically and should not be modified by hand.
-FROM continuumio/miniconda3
+FROM containers.ligo.org/docker/base:conda
LABEL name="bilby Base miniconda3" \
maintainer="Gregory Ashton <gregory.ashton@ligo.org>"
diff --git a/containers/v2-dockerfile-test-suite-python38 b/containers/v2-dockerfile-test-suite-python38
index 690055494c8798269a17a80386fe76de313a81ad..71cf85d0197a80f01ef5e7765d3a2875e40d8a11 100644
--- a/containers/v2-dockerfile-test-suite-python38
+++ b/containers/v2-dockerfile-test-suite-python38
@@ -1,6 +1,6 @@
# This dockerfile is written automatically and should not be modified by hand.
-FROM continuumio/miniconda3
+FROM containers.ligo.org/docker/base:conda
LABEL name="bilby Base miniconda3" \
maintainer="Gregory Ashton <gregory.ashton@ligo.org>"
diff --git a/docs/prior.txt b/docs/prior.txt
index f55aafe76324d984a2e013402477184a96d5170c..cea75744c1ce37145b97422aaad4dc1f9e5c984f 100644
--- a/docs/prior.txt
+++ b/docs/prior.txt
@@ -45,7 +45,7 @@ which provides extra functionality. For example, to sample from the prior:
.. code:: python
- >>> priors = bilby.core.priors.PriorDict()
+ >>> priors = bilby.core.prior.PriorDict()
>>> priors['a'] = bilby.prior.Uniform(minimum=0, maximum=10, name='a')
>>> priors['b'] = bilby.prior.Uniform(minimum=0, maximum=10, name='b')
>>> priors.sample()
@@ -89,7 +89,7 @@ matrix and standard deviations, e.g.:
>>> names = ['a', 'b'] # set the parameter names
>>> mu = [0., 5.] # the means of the parameters
>>> cov = [[2., 0.7], [0.7, 3.]] # the covariance matrix
- >>> mvg = bilby.core.priors.MultivariateGaussianDist(names, mus=mu, covs=cov)
+ >>> mvg = bilby.core.prior.MultivariateGaussianDist(names, mus=mu, covs=cov)
It is also possible to define a mixture model of multiple multivariate Gaussian modes of
different weights if required, e.g.:
@@ -100,7 +100,7 @@ different weights if required, e.g.:
>>> mu = [[0., 5.], [2., 7.]] # the means of the parameters
>>> cov = [[[2., 0.7], [0.7, 3.]], [[1., -0.9], [-0.9, 5.]]] # the covariance matrix
>>> weights = [0.3, 0.7] # weights of each mode
- >>> mvg = bilby.core.priors.MultivariateGaussianDist(names, mus=mu, covs=cov, nmodes=2, weights=weights)
+ >>> mvg = bilby.core.prior.MultivariateGaussianDist(names, mus=mu, covs=cov, nmodes=2, weights=weights)
The distribution can also have hard bounds on each parameter by supplying them.
diff --git a/examples/core_examples/slabspike_example.py b/examples/core_examples/slabspike_example.py
new file mode 100644
index 0000000000000000000000000000000000000000..d798512353178bf9f77940c0017a2e1f21aa1b35
--- /dev/null
+++ b/examples/core_examples/slabspike_example.py
@@ -0,0 +1,97 @@
+#!/usr/bin/env python
+"""
+An example of how to use slab-and-spike priors in bilby.
+In this example we look at a simple example with the sum
+of two Gaussian distributions, and we try to fit with
+up to three Gaussians.
+
+"""
+
+import bilby
+import numpy as np
+import matplotlib.pyplot as plt
+
+outdir = 'outdir'
+label = 'slabspike'
+bilby.utils.check_directory_exists_and_if_not_mkdir(outdir)
+
+
+# Here we define our model. We want to inject two Gaussians and recover with up to three.
+def gaussian(xs, amplitude, mu, sigma):
+ return amplitude / np.sqrt(2 * np.pi * sigma**2) * np.exp(-0.5 * (xs - mu)**2 / sigma**2)
+
+
+def triple_gaussian(xs, amplitude_0, amplitude_1, amplitude_2, mu_0, mu_1, mu_2, sigma_0, sigma_1, sigma_2, **kwargs):
+ return \
+ gaussian(xs, amplitude_0, mu_0, sigma_0) + \
+ gaussian(xs, amplitude_1, mu_1, sigma_1) + \
+ gaussian(xs, amplitude_2, mu_2, sigma_2)
+
+
+# Let's create our data set. We create 200 points on a grid.
+
+xs = np.linspace(-5, 5, 200)
+dx = xs[1] - xs[0]
+
+# Note for our injection parameters we set the amplitude of the second component to 0.
+injection_params = dict(amplitude_0=-3, mu_0=-4, sigma_0=4,
+ amplitude_1=0, mu_1=0, sigma_1=1,
+ amplitude_2=4, mu_2=3, sigma_2=3)
+
+# We calculate the injected curve and add some Gaussian noise on the data points
+sigma = 0.02
+p = bilby.core.prior.Gaussian(mu=0, sigma=sigma)
+ys = triple_gaussian(xs=xs, **injection_params) + p.sample(len(xs))
+
+plt.errorbar(xs, ys, yerr=sigma, fmt=".k", capsize=0, label='Injected data')
+plt.plot(xs, triple_gaussian(xs=xs, **injection_params), label='True signal')
+plt.legend()
+plt.savefig(f'{outdir}/{label}_injected_data')
+plt.clf()
+
+
+# Now we want to set up our priors.
+priors = bilby.core.prior.PriorDict()
+# For the slab-and-spike prior, we first need to define the 'slab' part, which is just a regular bilby prior.
+amplitude_slab_0 = bilby.core.prior.Uniform(minimum=-10, maximum=10, name='amplitude_0', latex_label='$A_0$')
+amplitude_slab_1 = bilby.core.prior.Uniform(minimum=-10, maximum=10, name='amplitude_1', latex_label='$A_1$')
+amplitude_slab_2 = bilby.core.prior.Uniform(minimum=-10, maximum=10, name='amplitude_2', latex_label='$A_2$')
+# We do the following to create the slab-and-spike prior. The spike height is somewhat arbitrary and can
+# be corrected in post-processing.
+priors['amplitude_0'] = bilby.core.prior.SlabSpikePrior(slab=amplitude_slab_0, spike_location=0, spike_height=0.1)
+priors['amplitude_1'] = bilby.core.prior.SlabSpikePrior(slab=amplitude_slab_1, spike_location=0, spike_height=0.1)
+priors['amplitude_2'] = bilby.core.prior.SlabSpikePrior(slab=amplitude_slab_2, spike_location=0, spike_height=0.1)
+# Our problem has a degeneracy in the ordering. In general, this problem is somewhat difficult to resolve properly.
+# See e.g. https://github.com/GregoryAshton/kookaburra/blob/master/src/priors.py#L72 for an implementation.
+# We resolve this by not letting the priors overlap in this case.
+priors['mu_0'] = bilby.core.prior.Uniform(minimum=-5, maximum=-2, name='mu_0', latex_label='$\mu_0$')
+priors['mu_1'] = bilby.core.prior.Uniform(minimum=-2, maximum=2, name='mu_1', latex_label='$\mu_1$')
+priors['mu_2'] = bilby.core.prior.Uniform(minimum=2, maximum=5, name='mu_2', latex_label='$\mu_2$')
+priors['sigma_0'] = bilby.core.prior.LogUniform(minimum=0.01, maximum=10, name='sigma_0', latex_label='$\sigma_0$')
+priors['sigma_1'] = bilby.core.prior.LogUniform(minimum=0.01, maximum=10, name='sigma_1', latex_label='$\sigma_1$')
+priors['sigma_2'] = bilby.core.prior.LogUniform(minimum=0.01, maximum=10, name='sigma_2', latex_label='$\sigma_2$')
+
+# Setting up the likelihood and running the samplers works the same as elsewhere.
+likelihood = bilby.core.likelihood.GaussianLikelihood(x=xs, y=ys, func=triple_gaussian, sigma=sigma)
+result = bilby.run_sampler(likelihood=likelihood, priors=priors, outdir=outdir, label=label,
+ sampler='dynesty', nlive=400)
+
+result.plot_corner(truths=injection_params)
+
+
+# Let's also plot the maximum likelihood fit along with the data.
+max_like_params = result.posterior.iloc[-1]
+plt.errorbar(xs, ys, yerr=sigma, fmt=".k", capsize=0, label='Injected data')
+plt.plot(xs, triple_gaussian(xs=xs, **injection_params), label='True signal')
+plt.plot(xs, triple_gaussian(xs=xs, **max_like_params), label='Max likelihood fit')
+plt.legend()
+plt.savefig(f'{outdir}/{label}_max_likelihood_recovery')
+plt.clf()
+
+# Finally, we can check what fraction of amplitude samples are exactly on the spike.
+spike_samples_0 = len(np.where(result.posterior['amplitude_0'] == 0.0)[0]) / len(result.posterior)
+spike_samples_1 = len(np.where(result.posterior['amplitude_1'] == 0.0)[0]) / len(result.posterior)
+spike_samples_2 = len(np.where(result.posterior['amplitude_2'] == 0.0)[0]) / len(result.posterior)
+print(f"{spike_samples_0 * 100:.2f}% of amplitude_0 samples are exactly 0.0")
+print(f"{spike_samples_1 * 100:.2f}% of amplitude_1 samples are exactly 0.0")
+print(f"{spike_samples_2 * 100:.2f}% of amplitude_2 samples are exactly 0.0")
diff --git a/examples/gw_examples/injection_examples/roq_example.py b/examples/gw_examples/injection_examples/roq_example.py
index 0ffdbf33817fa0813e630264608a38b06df6f7cc..69bff31df6e1fd6413d69de64669d53f9ee91f36 100644
--- a/examples/gw_examples/injection_examples/roq_example.py
+++ b/examples/gw_examples/injection_examples/roq_example.py
@@ -84,10 +84,10 @@ for key in ['a_1', 'a_2', 'tilt_1', 'tilt_2', 'theta_jn', 'phase', 'psi', 'ra',
priors[key] = injection_parameters[key]
for key in ['mass_1', 'mass_2']:
priors[key].minimum = max(priors[key].minimum, minimum_component_mass)
-priors['chirp_mass'] = bilby.core.prior.Constraint(
+priors['chirp_mass'] = bilby.core.prior.Uniform(
name='chirp_mass', minimum=float(minimum_chirp_mass),
maximum=float(maximum_chirp_mass))
-priors['mass_ratio'] = bilby.core.prior.Constraint(0.125, 1, name='mass_ratio')
+priors['mass_ratio'] = bilby.core.prior.Uniform(0.125, 1, name='mass_ratio')
priors['geocent_time'] = bilby.core.prior.Uniform(
injection_parameters['geocent_time'] - 0.1,
injection_parameters['geocent_time'] + 0.1, latex_label='$t_c$', unit='s')
diff --git a/examples/tutorials/visualising_the_results.ipynb b/examples/tutorials/visualising_the_results.ipynb
index 09c5660ad767fe38d210f2664e58d63fa0c45627..9bf2de0aaf5f276dfbe821bacd8bf706da669a60 100644
--- a/examples/tutorials/visualising_the_results.ipynb
+++ b/examples/tutorials/visualising_the_results.ipynb
@@ -3,9 +3,7 @@
{
"cell_type": "code",
"execution_count": null,
- "metadata": {
- "collapsed": true
- },
+ "metadata": {},
"outputs": [],
"source": [
"! rm visualising_the_results/*"
@@ -22,138 +20,9 @@
},
{
"cell_type": "code",
- "execution_count": 2,
+ "execution_count": null,
"metadata": {},
- "outputs": [
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "10:31 bilby INFO : No power spectral density provided, using aLIGO,zero detuning, high power.\n",
- "10:31 bilby INFO : Injected signal in H1:\n",
- "10:31 bilby INFO : optimal SNR = 120.28\n",
- "10:31 bilby INFO : matched filter SNR = 120.60-0.46j\n",
- "10:31 bilby INFO : mass_1 = 36.0\n",
- "10:31 bilby INFO : mass_2 = 29.0\n",
- "10:31 bilby INFO : a_1 = 0.4\n",
- "10:31 bilby INFO : a_2 = 0.3\n",
- "10:31 bilby INFO : tilt_1 = 0.5\n",
- "10:31 bilby INFO : tilt_2 = 1.0\n",
- "10:31 bilby INFO : phi_12 = 1.7\n",
- "10:31 bilby INFO : phi_jl = 0.3\n",
- "10:31 bilby INFO : luminosity_distance = 200.0\n",
- "10:31 bilby INFO : theta_jn = 0.4\n",
- "10:31 bilby INFO : phase = 1.3\n",
- "10:31 bilby INFO : ra = 1.375\n",
- "10:31 bilby INFO : dec = -1.2108\n",
- "10:31 bilby INFO : geocent_time = 1126259642.413\n",
- "10:31 bilby INFO : psi = 2.659\n",
- "10:31 bilby WARNING : The waveform_generator start_time is not equal to that of the provided interferometers. Overwriting the waveform_generator.\n",
- "10:31 bilby INFO : Running for label 'example', output will be saved to 'visualising_the_results'\n",
- "10:31 bilby INFO : Using LAL version Branch: None;Tag: lalsuite-v6.60;Id: 413788d4afeff8b759d8d75abe589ae4a846120c;;Builder: Unknown User <>;Repository status: CLEAN: All modifications committed\n",
- "10:31 bilby INFO : Search parameters:\n",
- "10:31 bilby INFO : mass_1 = Uniform(minimum=20, maximum=50, name='mass_1', latex_label='$m_1$', unit=None, boundary=None)\n",
- "10:31 bilby INFO : mass_2 = Uniform(minimum=20, maximum=50, name='mass_2', latex_label='$m_2$', unit=None, boundary=None)\n",
- "10:31 bilby INFO : luminosity_distance = Uniform(minimum=100, maximum=300, name='luminosity_distance', latex_label='$d_L$', unit=None, boundary=None)\n",
- "10:31 bilby INFO : a_1 = 0.4\n",
- "10:31 bilby INFO : a_2 = 0.3\n",
- "10:31 bilby INFO : tilt_1 = 0.5\n",
- "10:31 bilby INFO : tilt_2 = 1.0\n",
- "10:31 bilby INFO : phi_12 = 1.7\n",
- "10:31 bilby INFO : phi_jl = 0.3\n",
- "10:31 bilby INFO : theta_jn = 0.4\n",
- "10:31 bilby INFO : phase = 1.3\n",
- "10:31 bilby INFO : ra = 1.375\n",
- "10:31 bilby INFO : dec = -1.2108\n",
- "10:31 bilby INFO : geocent_time = 1126259642.413\n",
- "10:31 bilby INFO : psi = 2.659\n",
- "10:31 bilby INFO : Single likelihood evaluation took 2.305e-03 s\n",
- "10:31 bilby INFO : Using sampler Dynesty with kwargs {'bound': 'multi', 'sample': 'rwalk', 'verbose': True, 'periodic': None, 'reflective': None, 'check_point_delta_t': 600, 'nlive': 100, 'first_update': None, 'walks': 5, 'npdim': None, 'rstate': None, 'queue_size': None, 'pool': None, 'use_pool': None, 'live_points': None, 'logl_args': None, 'logl_kwargs': None, 'ptform_args': None, 'ptform_kwargs': None, 'enlarge': None, 'bootstrap': None, 'vol_dec': 0.5, 'vol_check': 2.0, 'facc': 0.5, 'slices': 5, 'update_interval': 60, 'print_func': <bound method Dynesty._print_func of <bilby.core.sampler.dynesty.Dynesty object at 0x1236747f0>>, 'dlogz': 0.1, 'maxiter': None, 'maxcall': None, 'logl_max': inf, 'add_live': True, 'print_progress': True, 'save_bounds': False, 'n_effective': None}\n",
- "10:31 bilby INFO : Checkpoint every n_check_point = 300000\n",
- "10:31 bilby INFO : Using dynesty version 0.9.7\n"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- " 1864| logz ratio=7255.416 +/- 0.541 | dlogz: 0.118 > 0.100000"
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "10:32 bilby WARNING : Run terminated with signal 2\n",
- "10:32 bilby INFO : Writing checkpoint file visualising_the_results/example_resume.pickle\n"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Exception while calling loglikelihood function:\n",
- " params: [ 35.99600559 28.99205241 200.17592464]\n",
- " args: []\n",
- " kwargs: {}\n",
- " exception:\n"
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "Traceback (most recent call last):\n",
- " File \"/Users/virginiademilio/Documents/Bilby/bilby/bilby/core/sampler/dynesty.py\", line 279, in _run_nested_wrapper\n",
- " self.sampler.run_nested(**kwargs)\n",
- "TypeError: run_nested() got an unexpected keyword argument 'n_effective'\n",
- "\n",
- "During handling of the above exception, another exception occurred:\n",
- "\n",
- "Traceback (most recent call last):\n",
- " File \"/Users/virginiademilio/anaconda3/envs/bilby_source/lib/python3.7/site-packages/dynesty/dynesty.py\", line 805, in __call__\n",
- " return self.func(x, *self.args, **self.kwargs)\n",
- " File \"/Users/virginiademilio/Documents/Bilby/bilby/bilby/core/sampler/base_sampler.py\", line 583, in log_likelihood\n",
- " return Sampler.log_likelihood(self, theta)\n",
- " File \"/Users/virginiademilio/Documents/Bilby/bilby/bilby/core/sampler/base_sampler.py\", line 381, in log_likelihood\n",
- " return self.likelihood.log_likelihood_ratio()\n",
- " File \"/Users/virginiademilio/Documents/Bilby/bilby/bilby/gw/likelihood.py\", line 244, in log_likelihood_ratio\n",
- " self.waveform_generator.frequency_domain_strain(self.parameters)\n",
- " File \"/Users/virginiademilio/Documents/Bilby/bilby/bilby/gw/waveform_generator.py\", line 119, in frequency_domain_strain\n",
- " transformed_model_data_points=self.time_array)\n",
- " File \"/Users/virginiademilio/Documents/Bilby/bilby/bilby/gw/waveform_generator.py\", line 158, in _calculate_strain\n",
- " model_strain = self._strain_from_model(model_data_points, model)\n",
- " File \"/Users/virginiademilio/Documents/Bilby/bilby/bilby/gw/waveform_generator.py\", line 170, in _strain_from_model\n",
- " return model(model_data_points, **self.parameters)\n",
- " File \"/Users/virginiademilio/Documents/Bilby/bilby/bilby/gw/source.py\", line 71, in lal_binary_black_hole\n",
- " phi_jl=phi_jl, **waveform_kwargs)\n",
- " File \"/Users/virginiademilio/Documents/Bilby/bilby/bilby/gw/source.py\", line 272, in _base_lal_cbc_fd_waveform\n",
- " waveform_dictionary, approximant)\n",
- " File \"/Users/virginiademilio/Documents/Bilby/bilby/bilby/gw/utils.py\", line 798, in lalsim_SimInspiralChooseFDWaveform\n",
- " waveform_dictionary, approximant)\n",
- " File \"/Users/virginiademilio/Documents/Bilby/bilby/bilby/core/sampler/dynesty.py\", line 385, in write_current_state_and_exit\n",
- " sys.exit(130)\n",
- "SystemExit: 130\n"
- ]
- },
- {
- "ename": "SystemExit",
- "evalue": "130",
- "output_type": "error",
- "traceback": [
- "An exception has occurred, use %tb to see the full traceback.\n",
- "\u001b[0;31mSystemExit\u001b[0m\u001b[0;31m:\u001b[0m 130\n"
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "/Users/virginiademilio/anaconda3/envs/bilby_source/lib/python3.7/site-packages/IPython/core/interactiveshell.py:3334: UserWarning: To exit: use 'exit', 'quit', or Ctrl-D.\n",
- " warn(\"To exit: use 'exit', 'quit', or Ctrl-D.\", stacklevel=1)\n"
- ]
- }
- ],
+ "outputs": [],
"source": [
"import bilby\n",
"import matplotlib.pyplot as plt\n",
@@ -363,13 +232,56 @@
"result.plot_marginals()\n",
"plt.show()"
]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%% md\n"
+ }
+ },
+ "source": [
+ "#### Best-Fit Time Domain Waveform plot\n",
+ "Some plots sepcific to compact binary coalescence parameter estimation results can\n",
+ "be created by re-loading the result as a `CBCResult`:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "from bilby.gw.result import CBCResult\n",
+ "\n",
+ "cbc_result = CBCResult.from_json(\"visualising_the_results/example_result.json\")\n",
+ "cbc_result.plot_waveform_posterior()\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "collapsed": false
+ },
+ "source": [
+ "Again, notice that the plot is saved as a \"waveform.png\" in the output dir.\n",
+ "\n",
+ "\n",
+ "\n"
+ ]
}
],
"metadata": {
"kernelspec": {
- "display_name": "Bilby (source-install)",
+ "display_name": "Python 3",
"language": "python",
- "name": "bilby_source"
+ "name": "python3"
},
"language_info": {
"codemirror_mode": {
@@ -382,15 +294,6 @@
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.3"
- },
- "pycharm": {
- "stem_cell": {
- "cell_type": "raw",
- "metadata": {
- "collapsed": false
- },
- "source": []
- }
}
},
"nbformat": 4,
diff --git a/setup.py b/setup.py
index abb40ecd07fde6a08cf24cf463c2f0f07fd94d3c..0882ade9b33e1477ff5ffccad7ee8a22be36fecc 100644
--- a/setup.py
+++ b/setup.py
@@ -64,7 +64,7 @@ def readfile(filename):
return filecontents
-VERSION = '1.0.2'
+VERSION = '1.0.4'
version_file = write_version_file(VERSION)
long_description = get_long_description()
diff --git a/test/check_author_list.py b/test/check_author_list.py
new file mode 100644
index 0000000000000000000000000000000000000000..1b082e219da9e6105185cd47f0a9bd3b03e4287d
--- /dev/null
+++ b/test/check_author_list.py
@@ -0,0 +1,28 @@
+""" A script to verify that the .AUTHOR.md file is up to date """
+
+import re
+import subprocess
+
+special_cases = ["plasky", "thomas", "mj-will"]
+AUTHORS_list = []
+with open("AUTHORS.md", "r") as f:
+ AUTHORS_list = " ".join([line for line in f]).lower()
+
+
+lines = subprocess.check_output(["git", "shortlog", "HEAD", "-sn"]).decode("utf-8").split("\n")
+
+if len(lines) == 0:
+ raise Exception("No authors to check against")
+
+fail_test = False
+for line in lines:
+ line = line.replace(".", " ")
+ line = re.sub('([A-Z][a-z]+)', r' \1', re.sub('([A-Z]+)', r' \1', line))
+ for element in line.split()[1:]:
+ element = element.lower()
+ if element not in AUTHORS_list and element not in special_cases:
+ print("Failure: {} not in AUTHOR.md".format(element))
+ fail_test += True
+
+if fail_test:
+ raise Exception("Author check list failed.. have you added your name to the .AUTHOR file?")
diff --git a/test/core/prior/conditional_test.py b/test/core/prior/conditional_test.py
index 0e44fda3691172e1ca8618d7ace3a172de991912..a76f10a4fa379d34b4fe35499a76fb4005506741 100644
--- a/test/core/prior/conditional_test.py
+++ b/test/core/prior/conditional_test.py
@@ -110,7 +110,7 @@ class TestConditionalPrior(unittest.TestCase):
test_parameter_2=self.test_variable_2,
)
- def test_rescale_prob_update_conditions(self):
+ def test_prob_calls_update_conditions(self):
with mock.patch.object(self.prior, "update_conditions") as m:
self.prior.prob(
1,
@@ -138,6 +138,21 @@ class TestConditionalPrior(unittest.TestCase):
]
m.assert_has_calls(calls)
+ def test_cdf_calls_update_conditions(self):
+ self.prior = bilby.core.prior.ConditionalUniform(
+ condition_func=self.condition_func, minimum=self.minimum, maximum=self.maximum
+ )
+ with mock.patch.object(self.prior, "update_conditions") as m:
+ self.prior.cdf(
+ 1,
+ test_parameter_1=self.test_variable_1,
+ test_parameter_2=self.test_variable_2,
+ )
+ m.assert_called_with(
+ test_parameter_1=self.test_variable_1,
+ test_parameter_2=self.test_variable_2,
+ )
+
def test_reset_to_reference_parameters(self):
self.prior.minimum = 10
self.prior.maximum = 20
diff --git a/test/core/prior/slabspike_test.py b/test/core/prior/slabspike_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..d2cdcc55a0fbf9d3ef64c71b9420b321ee11e384
--- /dev/null
+++ b/test/core/prior/slabspike_test.py
@@ -0,0 +1,202 @@
+import numpy as np
+import unittest
+
+import bilby
+from bilby.core.prior.slabspike import SlabSpikePrior
+from bilby.core.prior.analytical import Uniform, PowerLaw, LogUniform, TruncatedGaussian, \
+ Beta, Gaussian, Cosine, Sine, HalfGaussian, LogNormal, Exponential, StudentT, Logistic, \
+ Cauchy, Gamma, ChiSquared
+
+
+class TestSlabSpikePrior(unittest.TestCase):
+
+ def setUp(self):
+ self.minimum = 0
+ self.maximum = 1
+ self.spike_loc = 0.5
+ self.spike_height = 0.3
+ self.slab = bilby.core.prior.Prior(minimum=self.minimum, maximum=self.maximum)
+ self.prior = SlabSpikePrior(
+ slab=self.slab, spike_location=self.spike_loc, spike_height=self.spike_height)
+
+ def tearDown(self):
+ del self.minimum
+ del self.maximum
+ del self.spike_loc
+ del self.spike_height
+ del self.prior
+ del self.slab
+
+ def test_slab_fraction(self):
+ expected = 1 - self.spike_height
+ self.assertEqual(expected, self.prior.slab_fraction)
+
+ def test_spike_loc(self):
+ self.assertEqual(self.spike_loc, self.prior.spike_location)
+
+ def test_set_spike_loc_none(self):
+ self.prior.spike_location = None
+ self.assertEqual(self.prior.minimum, self.prior.spike_location)
+
+ def test_set_spike_loc_outside_domain(self):
+ with self.assertRaises(ValueError):
+ self.prior.spike_location = 1.5
+
+ def test_set_spike_loc_maximum(self):
+ self.prior.spike_location = self.maximum
+ self.assertEqual(self.maximum, self.prior.spike_location)
+
+ def test_class_name(self):
+ expected = "SlabSpikePrior"
+ self.assertEqual(expected, self.prior.__class__.__name__)
+ self.assertEqual(expected, self.prior.__class__.__qualname__)
+
+ def test_set_spike_height_outside_domain(self):
+ with self.assertRaises(ValueError):
+ self.prior.spike_height = 1.5
+
+ def test_set_spike_height_domain_edge(self):
+ self.prior.spike_height = 0
+ self.prior.spike_height = 1
+
+
+class TestSlabSpikeClasses(unittest.TestCase):
+
+ def setUp(self):
+ self.minimum = 0.4
+ self.maximum = 2.4
+ self.spike_loc = 1.5
+ self.spike_height = 0.3
+
+ self.slabs = [
+ Uniform(minimum=self.minimum, maximum=self.maximum),
+ PowerLaw(minimum=self.minimum, maximum=self.maximum, alpha=2),
+ LogUniform(minimum=self.minimum, maximum=self.maximum),
+ TruncatedGaussian(minimum=self.minimum, maximum=self.maximum, mu=0, sigma=1),
+ Beta(minimum=self.minimum, maximum=self.maximum, alpha=1, beta=1),
+ Gaussian(mu=0, sigma=1),
+ Cosine(),
+ Sine(),
+ HalfGaussian(sigma=1),
+ LogNormal(mu=1, sigma=2),
+ Exponential(mu=2),
+ StudentT(df=2),
+ Logistic(mu=2, scale=1),
+ Cauchy(alpha=1, beta=2),
+ Gamma(k=1, theta=1.),
+ ChiSquared(nu=2)]
+ self.slab_spikes = [SlabSpikePrior(slab, spike_height=self.spike_height, spike_location=self.spike_loc)
+ for slab in self.slabs]
+ self.test_nodes_finite_support = np.linspace(self.minimum, self.maximum, 1000)
+ self.test_nodes_infinite_support = np.linspace(-10, 10, 1000)
+ self.test_nodes = [self.test_nodes_finite_support
+ if np.isinf(slab.minimum) or np.isinf(slab.maximum)
+ else self.test_nodes_finite_support for slab in self.slabs]
+
+ def tearDown(self):
+ del self.minimum
+ del self.maximum
+ del self.spike_loc
+ del self.spike_height
+ del self.slabs
+ del self.test_nodes_finite_support
+ del self.test_nodes_infinite_support
+
+ def test_prob_on_slab(self):
+ for slab, slab_spike, test_nodes in zip(self.slabs, self.slab_spikes, self.test_nodes):
+ expected = slab.prob(test_nodes) * slab_spike.slab_fraction
+ actual = slab_spike.prob(test_nodes)
+ self.assertTrue(np.allclose(expected, actual, rtol=1e-5))
+
+ def test_prob_on_spike(self):
+ for slab_spike in self.slab_spikes:
+ self.assertEqual(np.inf, slab_spike.prob(self.spike_loc))
+
+ def test_ln_prob_on_slab(self):
+ for slab, slab_spike, test_nodes in zip(self.slabs, self.slab_spikes, self.test_nodes):
+ expected = slab.ln_prob(test_nodes) + np.log(slab_spike.slab_fraction)
+ actual = slab_spike.ln_prob(test_nodes)
+ self.assertTrue(np.array_equal(expected, actual))
+
+ def test_ln_prob_on_spike(self):
+ for slab_spike in self.slab_spikes:
+ self.assertEqual(np.inf, slab_spike.ln_prob(self.spike_loc))
+
+ def test_inverse_cdf_below_spike_with_spike_at_minimum(self):
+ for slab in self.slabs:
+ slab_spike = SlabSpikePrior(slab=slab, spike_height=0.4, spike_location=slab.minimum)
+ self.assertEqual(0, slab_spike.inverse_cdf_below_spike)
+
+ def test_inverse_cdf_below_spike_with_spike_at_maximum(self):
+ for slab in self.slabs:
+ slab_spike = SlabSpikePrior(slab=slab, spike_height=0.4, spike_location=slab.maximum)
+ expected = 1 - slab_spike.spike_height
+ actual = slab_spike.inverse_cdf_below_spike
+ self.assertEqual(expected, actual)
+
+ def test_inverse_cdf_below_spike_arbitrary_position(self):
+ pass
+
+ def test_cdf_below_spike(self):
+ for slab, slab_spike, test_nodes in zip(self.slabs, self.slab_spikes, self.test_nodes):
+ test_nodes = test_nodes[np.where(test_nodes < self.spike_loc)]
+ expected = slab.cdf(test_nodes) * slab_spike.slab_fraction
+ actual = slab_spike.cdf(test_nodes)
+ self.assertTrue(np.allclose(expected, actual, rtol=1e-5))
+
+ def test_cdf_at_spike(self):
+ for slab, slab_spike in zip(self.slabs, self.slab_spikes):
+ expected = slab.cdf(self.spike_loc) * slab_spike.slab_fraction
+ actual = slab_spike.cdf(self.spike_loc)
+ self.assertTrue(np.allclose(expected, actual, rtol=1e-5))
+
+ def test_cdf_above_spike(self):
+ for slab, slab_spike, test_nodes in zip(self.slabs, self.slab_spikes, self.test_nodes):
+ test_nodes = test_nodes[np.where(test_nodes > self.spike_loc)]
+ expected = slab.cdf(test_nodes) * slab_spike.slab_fraction + self.spike_height
+ actual = slab_spike.cdf(test_nodes)
+ self.assertTrue(np.array_equal(expected, actual))
+
+ def test_cdf_at_minimum(self):
+ for slab_spike in self.slab_spikes:
+ expected = 0
+ actual = slab_spike.cdf(slab_spike.minimum)
+ self.assertEqual(expected, actual)
+
+ def test_cdf_at_maximum(self):
+ for slab_spike in self.slab_spikes:
+ expected = 1
+ actual = slab_spike.cdf(slab_spike.maximum)
+ self.assertEqual(expected, actual)
+
+ def test_rescale_no_spike(self):
+ for slab in self.slabs:
+ slab_spike = SlabSpikePrior(slab=slab, spike_height=0, spike_location=slab.minimum)
+ vals = np.linspace(0, 1, 1000)
+ expected = slab.rescale(vals)
+ actual = slab_spike.rescale(vals)
+ print(slab)
+ self.assertTrue(np.allclose(expected, actual, rtol=1e-5))
+
+ def test_rescale_below_spike(self):
+ for slab, slab_spike in zip(self.slabs, self.slab_spikes):
+ vals = np.linspace(0, slab_spike.inverse_cdf_below_spike, 1000)
+ expected = slab.rescale(vals / slab_spike.slab_fraction)
+ actual = slab_spike.rescale(vals)
+ self.assertTrue(np.allclose(expected, actual, rtol=1e-5))
+
+ def test_rescale_at_spike(self):
+ for slab, slab_spike in zip(self.slabs, self.slab_spikes):
+ vals = np.linspace(slab_spike.inverse_cdf_below_spike,
+ slab_spike.inverse_cdf_below_spike + slab_spike.spike_height, 1000)
+ expected = np.ones(len(vals)) * slab.rescale(vals[0] / slab_spike.slab_fraction)
+ actual = slab_spike.rescale(vals)
+ self.assertTrue(np.allclose(expected, actual, rtol=1e-5))
+
+ def test_rescale_above_spike(self):
+ for slab, slab_spike in zip(self.slabs, self.slab_spikes):
+ vals = np.linspace(slab_spike.inverse_cdf_below_spike + self.spike_height, 1, 1000)
+ expected = np.ones(len(vals)) * slab.rescale(
+ (vals - self.spike_height) / slab_spike.slab_fraction)
+ actual = slab_spike.rescale(vals)
+ self.assertTrue(np.allclose(expected, actual, rtol=1e-5))
diff --git a/test/core/sampler/dnest4_test.py b/test/core/sampler/dnest4_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..fc67a0f8f3dbe1c37e6301bce95ef69e9fae6570
--- /dev/null
+++ b/test/core/sampler/dnest4_test.py
@@ -0,0 +1,61 @@
+import unittest
+
+from mock import MagicMock
+
+import bilby
+
+
+class TestDnest4(unittest.TestCase):
+ def setUp(self):
+ self.likelihood = MagicMock()
+ self.priors = bilby.core.prior.PriorDict(
+ dict(a=bilby.core.prior.Uniform(0, 1), b=bilby.core.prior.Uniform(0, 1))
+ )
+ self.sampler = bilby.core.sampler.DNest4(
+ self.likelihood,
+ self.priors,
+ outdir="outdir",
+ label="label",
+ use_ratio=False,
+ plot=False,
+ skip_import_verification=True,
+ )
+
+ def tearDown(self):
+ del self.likelihood
+ del self.priors
+ del self.sampler
+
+ def test_default_kwargs(self):
+ expected = dict(
+ max_num_levels=20, num_steps=500,
+ new_level_interval=10000, num_per_step=10000,
+ thread_steps=1, num_particles=1000, lam=10.0,
+ beta=100, seed=None, verbose=True, backend='memory'
+ )
+ for key in self.sampler.kwargs.keys():
+ print(
+ "key={}, expected={}, actual={}".format(
+ key, expected[key], self.sampler.kwargs[key]
+ )
+ )
+ self.assertDictEqual(expected, self.sampler.kwargs)
+
+ def test_translate_kwargs(self):
+ expected = dict(
+ max_num_levels=20, num_steps=500,
+ new_level_interval=10000, num_per_step=10000,
+ thread_steps=1, num_particles=1000, lam=10.0,
+ beta=100, seed=None, verbose=True, backend='memory'
+ )
+
+ for equiv in bilby.core.sampler.base_sampler.NestedSampler.npoints_equiv_kwargs:
+ new_kwargs = self.sampler.kwargs.copy()
+ del new_kwargs["num_particles"]
+ new_kwargs[equiv] = 1000
+ self.sampler.kwargs = new_kwargs
+ self.assertDictEqual(expected, self.sampler.kwargs)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/test/core/sampler/sampler_run_test.py b/test/core/sampler/sampler_run_test.py
index 2d697494409d0b8064af22959d6767149047b073..3278ddc0f1f0b70f0ebb42e7e9e617d367c9777f 100644
--- a/test/core/sampler/sampler_run_test.py
+++ b/test/core/sampler/sampler_run_test.py
@@ -40,6 +40,15 @@ class TestRunningSamplers(unittest.TestCase):
resume=False,
)
+ def test_run_dnest4(self):
+ _ = bilby.run_sampler(
+ likelihood=self.likelihood,
+ priors=self.priors,
+ sampler="dnest4",
+ nlive=100,
+ save=False,
+ )
+
def test_run_dynesty(self):
_ = bilby.run_sampler(
likelihood=self.likelihood,