def test_madau_dickinson_normalised(self): model = redshift.MadauDickinsonRedshift() priors = PriorDict() priors["gamma"] = Uniform(-15, 15) priors["kappa"] = Uniform(-15, 15) priors["z_peak"] = Uniform(0, 5) self._run_model_normalisation(model=model, priors=priors)
def test_absolute_overlap(self): priors = BBHPriorDict(aligned_spin=True) del priors["mass_1"], priors["mass_2"] priors["total_mass"] = Uniform(5, 50) priors["mass_ratio"] = Uniform(0.5, 1) priors["geocent_time"] = Uniform(-10, 10) n_samples = 100 all_parameters = pd.DataFrame(priors.sample(n_samples)) overlaps = list() for ii in range(n_samples): parameters = dict(all_parameters.iloc[ii]) bilby_pols = self.bilby_wfg.frequency_domain_strain(parameters) gpu_pols = self.gpu_wfg.frequency_domain_strain(parameters) bilby_strain = self.ifo.get_detector_response( waveform_polarizations=bilby_pols, parameters=parameters) gpu_strain = self.ifo.get_detector_response( waveform_polarizations=gpu_pols, parameters=parameters) inner_product = noise_weighted_inner_product( aa=bilby_strain, bb=gpu_strain, power_spectral_density=self.ifo.power_spectral_density_array, duration=self.duration) overlap = (inner_product / self.ifo.optimal_snr_squared(signal=bilby_strain)**0.5 / self.ifo.optimal_snr_squared(signal=gpu_strain)**0.5) overlaps.append(overlap) self.assertTrue(min(np.abs(overlaps)) > 0.995)
def setUp(self): self.likelihood = GaussianLikelihood( x=np.linspace(0, 1, 2), y=np.linspace(0, 1, 2), func=lambda x, **kwargs: x, sigma=1, ) self.priors = PriorDict(dict(a=Uniform(0, 1), b=Uniform(0, 1))) self._args = (self.likelihood, self.priors) self._kwargs = dict( outdir="outdir", label="label", use_ratio=False, plot=False, skip_import_verification=True, ) self.sampler = Ptemcee(*self._args, **self._kwargs) self.expected = dict( ntemps=10, nwalkers=100, Tmax=None, betas=None, a=2.0, adaptation_lag=10000, adaptation_time=100, random=None, adapt=False, swap_ratios=False, )
def setUp(self): self.costilts = xp.linspace(-1, 1, 1000) self.test_data = dict( cos_tilt_1=xp.einsum("i,j->ij", self.costilts, xp.ones_like(self.costilts)), cos_tilt_2=xp.einsum("i,j->ji", self.costilts, xp.ones_like(self.costilts)), ) self.prior = PriorDict(dict(xi_spin=Uniform(0, 1), sigma_spin=Uniform(0, 4))) self.n_test = 100
def test_bilby_to_lalinference(self): mass_1 = [1, 20] mass_2 = [1, 20] chirp_mass = [1, 5] mass_ratio = [0.125, 1] bilby_prior = BBHPriorDict(dictionary=dict( chirp_mass=Uniform(name='chirp_mass', minimum=chirp_mass[0], maximum=chirp_mass[1]), mass_ratio=Uniform(name='mass_ratio', minimum=mass_ratio[0], maximum=mass_ratio[1]), mass_2=Constraint(name='mass_2', minimum=mass_1[0], maximum=mass_1[1]), mass_1=Constraint(name='mass_1', minimum=mass_2[0], maximum=mass_2[1]))) lalinf_prior = BBHPriorDict(dictionary=dict( mass_ratio=Constraint(name='mass_ratio', minimum=mass_ratio[0], maximum=mass_ratio[1]), chirp_mass=Constraint(name='chirp_mass', minimum=chirp_mass[0], maximum=chirp_mass[1]), mass_2=Uniform(name='mass_2', minimum=mass_1[0], maximum=mass_1[1]), mass_1=Uniform(name='mass_1', minimum=mass_2[0], maximum=mass_2[1]))) nsamples = 5000 bilby_samples = bilby_prior.sample(nsamples) bilby_samples, _ = conversion.convert_to_lal_binary_black_hole_parameters( bilby_samples) # Quicker way to generate LA prior samples (rather than specifying Constraint) lalinf_samples = [] while len(lalinf_samples) < nsamples: s = lalinf_prior.sample() if s["mass_1"] < s["mass_2"]: s["mass_1"], s["mass_2"] = s["mass_2"], s["mass_1"] if s["mass_2"] / s["mass_1"] > 0.125: lalinf_samples.append(s) lalinf_samples = pd.DataFrame(lalinf_samples) lalinf_samples["mass_ratio"] = lalinf_samples["mass_2"] / lalinf_samples["mass_1"] # Construct fake result object result = bilby.core.result.Result() result.search_parameter_keys = ["mass_ratio", "chirp_mass"] result.meta_data = dict() result.priors = bilby_prior result.posterior = pd.DataFrame(bilby_samples) result_converted = bilby.gw.prior.convert_to_flat_in_component_mass_prior(result) if "plot" in sys.argv: # Useful for debugging plt.hist(bilby_samples["mass_ratio"], bins=50, density=True, alpha=0.5) plt.hist(result_converted.posterior["mass_ratio"], bins=50, density=True, alpha=0.5) plt.hist(lalinf_samples["mass_ratio"], bins=50, alpha=0.5, density=True) plt.show() # Check that the non-reweighted posteriors fail a KS test ks = ks_2samp(bilby_samples["mass_ratio"], lalinf_samples["mass_ratio"]) print("Non-reweighted KS test = ", ks) self.assertFalse(ks.pvalue > 0.05) # Check that the non-reweighted posteriors pass a KS test ks = ks_2samp(result_converted.posterior["mass_ratio"], lalinf_samples["mass_ratio"]) print("Reweighted KS test = ", ks) self.assertTrue(ks.pvalue > 0.001)
def setUp(self): self.a_array = xp.linspace(0, 1, 1000) self.test_data = dict( a_1=xp.einsum('i,j->ij', self.a_array, xp.ones_like(self.a_array)), a_2=xp.einsum('i,j->ji', self.a_array, xp.ones_like(self.a_array))) self.prior = PriorDict( dict(amax=Uniform(0.3, 1), alpha_chi=Uniform(1, 4), beta_chi=Uniform(1, 4))) self.n_test = 100
def test_base_distribution(self): """ Test the BaseDistribution object. """ name = "test" # test failure for unknown distribution with pytest.raises(ValueError): BaseDistribution(name, "kjsgdkdgkjgsda") # test failure for inappropriate bounds with pytest.raises(ValueError): BaseDistribution(name, "gaussian", low=0.0, high=-1.0) # test failure for unknown hyperparameter name with pytest.raises(KeyError): hyper = {"mu": [1], "dkgwkufd": [2]} BaseDistribution(name, "gaussian", hyperparameters=hyper) # test failure with invalid hyperparameter type with pytest.raises(TypeError): BaseDistribution(name, "gaussian", hyperparameters="blah") with pytest.raises(TypeError): BaseDistribution(name, "exponential", hyperparameters="blah") # test default log_pdf is NaN hyper = {"mu": 2.0} dist = BaseDistribution(name, "exponential", hyperparameters=hyper) assert dist["mu"] == hyper["mu"] assert np.isnan(dist.log_pdf({}, 0)) assert dist.sample({}) is None # test failure when getting unknown item with pytest.raises(KeyError): _ = dist["kgksda"] del dist # test setter failure dist = BaseDistribution(name, "exponential") with pytest.raises(KeyError): dist["madbks"] = Uniform(0.0, 1.0, "mu") # test setter dist["mu"] = Uniform(0.0, 1.0, "mu") assert isinstance(dist["mu"], Uniform) # test failure with invalid hyperparameter type with pytest.raises(TypeError): hyper = "blah" BaseDistribution(name, "deltafunction", hyperparameters=hyper)
def test_resampling_posteriors(self): priors = PriorDict( dict(a=Uniform(0, 2), b=Uniform(0, 2), c=Uniform(0, 2))) samples = priors.sample(100) like = HyperparameterLikelihood( posteriors=self.data, hyper_prior=self.model, selection_function=self.selection_function, ln_evidences=self.ln_evidences, ) new_samples = like.posterior_predictive_resample(samples=samples) for key in new_samples: self.assertEqual(new_samples[key].shape, like.data[key].shape)
def test_numba_likelihood(self): """ Test likelihood using numba against the standard likelihood. """ het = HeterodynedData(self.data, times=self.times, detector=self.detector, par=self.parfile) priors = dict() priors["h0"] = Uniform(0.0, 1.0e-23, "h0") for likelihood in ["gaussian", "studentst"]: like1 = TargetedPulsarLikelihood(het, PriorDict(priors), likelihood=likelihood) like1.parameters = {"h0": 1e-24} like2 = TargetedPulsarLikelihood(het, PriorDict(priors), likelihood=likelihood, numba=True) like2.parameters = {"h0": 1e-24} assert like1.log_likelihood() == like2.log_likelihood()
def test_exponential(self): """ Test the ExponentialDistribution class. """ name = "test" dist = ExponentialDistribution(name, mu=1.0) assert dist["mu"] == 1.0 assert dist.fixed["mu"] is True dist = ExponentialDistribution(name, mu=Uniform(0.0, 1.0, "mu")) value = -1.0 hyper = {"mu": 0.5} assert isinstance(dist["mu"], Uniform) assert dist.fixed["mu"] is False assert dist.log_pdf(value, hyper) == -np.inf assert np.exp(dist.log_pdf(value, hyper)) == dist.pdf(value, hyper) # check drawn sample is within bounds assert dist.low < dist.sample(hyper) < dist.high # draw multiple samples N = 100 samples = dist.sample(hyper, size=N) assert len(samples) == N assert np.all((samples > dist.low) & (samples < dist.high)) value = 1.0 hyper = {"kgsdg": 0.5} with pytest.raises(KeyError): dist.log_pdf(value, hyper)
def test_wrong_inputs(self): """ Test that exceptions are raised for incorrect inputs to the TargetedPulsarLikelihood. """ with pytest.raises(TypeError): TargetedPulsarLikelihood(None, None) # create HeterodynedData object (no par file) het = HeterodynedData(self.data, times=self.times, detector=self.detector) priors = dict() priors["h0"] = Uniform(0.0, 1.0e-23, "h0") # error with no par file with pytest.raises(ValueError): TargetedPulsarLikelihood(het, PriorDict(priors)) het = HeterodynedData(self.data, times=self.times, detector=self.detector, par=self.parfile) mhet = MultiHeterodynedData(het) # multihet object for testing with pytest.raises(TypeError): TargetedPulsarLikelihood(het, None) with pytest.raises(TypeError): TargetedPulsarLikelihood(mhet, None)
def test_includephase_likelihood(self): """ Test the likelihood when include phase is set to True. """ het = HeterodynedData(self.data, times=self.times, detector=self.detector, par=self.parfile) priors = dict() priors["h0"] = Uniform(0.0, 1.0e-23, "h0") # run with includephase as False like1 = TargetedPulsarLikelihood(het, PriorDict(priors), likelihood="studentst") like1.parameters = {"h0": 1e-24} logl1 = like1.log_likelihood() # set includephase to True like2 = TargetedPulsarLikelihood(het, PriorDict(priors), likelihood="studentst") like2.parameters = {"h0": 1e-24} like2.include_phase = True logl2 = like2.log_likelihood() print(f"{logl1:.15f} {logl2:.15f}") assert np.allclose([logl1], [logl2], atol=1e-10, rtol=0.0)
def test_create_distribution(self): """ Test the create_distribution() function. """ name = "test" with pytest.raises(ValueError): create_distribution(name, "kjbskdvakvkd") with pytest.raises(TypeError): create_distribution(name, 2.3) gausskwargs = {"mus": [1.0, 2.0], "sigmas": [1.0, 2.0]} dist = create_distribution(name, "Gaussian", gausskwargs) assert isinstance(dist, BoundedGaussianDistribution) assert (dist["mu0"] == gausskwargs["mus"][0] and dist["mu1"] == gausskwargs["mus"][1]) assert (dist["sigma0"] == gausskwargs["sigmas"][0] and dist["sigma1"] == gausskwargs["sigmas"][1]) del dist expkwargs = {"mu": Uniform(0.0, 1.0, "mu")} dist = create_distribution(name, "Exponential", expkwargs) assert isinstance(dist, ExponentialDistribution) assert dist["mu"] == expkwargs["mu"] newdist = create_distribution(name, dist) assert isinstance(newdist, ExponentialDistribution) assert newdist["mu"] == dist["mu"] deltakwargs = {"peak": Uniform(0.0, 1.0, "peak")} dist = create_distribution(name, "DeltaFunction", deltakwargs) assert isinstance(dist, DeltaFunctionDistribution) assert dist["peak"] == deltakwargs["peak"] powerlawkwargs = { "alpha": Uniform(-1, 1, name="alpha"), "minimum": 0.00001, "maximum": 1000.0, } dist = create_distribution(name, "PowerLaw", powerlawkwargs) assert isinstance(dist, PowerLawDistribution) assert dist["alpha"] == powerlawkwargs["alpha"] assert dist["minimum"] == powerlawkwargs["minimum"] assert dist["maximum"] == powerlawkwargs["maximum"]
def test_powerlaw(self): """ Test the PowerLawDistribution class. """ name = "test" dist = PowerLawDistribution(name, alpha=1.0, minimum=0.1, maximum=10.0) assert dist["alpha"] == 1.0 assert dist.fixed["alpha"] is True assert dist["minimum"] == 0.1 assert dist.fixed["minimum"] is True assert dist["maximum"] == 10.0 assert dist.fixed["maximum"] is True # test out of bounds with pytest.raises(ValueError): PowerLawDistribution(name, alpha=1.0, minimum=-1.0, maximum=10.0) with pytest.raises(ValueError): PowerLawDistribution(name, alpha=1.0, minimum=-np.inf, maximum=10.0) with pytest.raises(ValueError): PowerLawDistribution(name, alpha=1.0, minimum=1.0, maximum=0.5) with pytest.raises(ValueError): PowerLawDistribution(name, alpha=1.0, minimum=1.0, maximum=-np.inf) minimum = 0.001 maximum = 10.0 dist = PowerLawDistribution(name, alpha=Uniform(0.0, 1.0, "alpha"), minimum=minimum, maximum=maximum) value = -1.0 hyper = {"alpha": 0.5} assert isinstance(dist["alpha"], Uniform) assert dist.fixed["alpha"] is False assert dist.log_pdf(value, hyper) == -np.inf assert np.exp(dist.log_pdf(value, hyper)) == dist.pdf(value, hyper) # check drawn sample is within bounds assert minimum < dist.sample(hyper) < maximum # draw multiple samples N = 100 samples = dist.sample(hyper, size=N) assert len(samples) == N assert np.all((samples > minimum) & (samples < maximum)) value = 1.0 hyper = {"kgsdg": 0.5} with pytest.raises(KeyError): dist.log_pdf(value, hyper)
def convert_to_bilby_res(dat): posteriors = dl_to_ld(dat['posteriors']) trues = dl_to_ld(dat['trues']) results = [] p = PriorDict( dict(cos_theta_12=Uniform(-1, 1), cos_tilt_1=Uniform(-1, 1), weights=Uniform(0, 1))) for i in tqdm(range(len(posteriors)), desc="Converting to Results"): r = Result() r.search_parameter_keys = ['cos_tilt_1', 'cos_theta_12', 'weights'] r.injection_parameters = trues[i] r.priors = p r.label = dat['labels'][i] r.outdir = "plots" r.posterior = pd.DataFrame(posteriors[i]) results.append(r) return results
def setUp(self): self.a_array = xp.linspace(0, 1, 1000) self.costilts = xp.linspace(-1, 1, 1000) self.test_data = dict( a_1=xp.einsum("i,j->ij", self.a_array, xp.ones_like(self.a_array)), a_2=xp.einsum("i,j->ji", self.a_array, xp.ones_like(self.a_array)), cos_tilt_1=xp.einsum("i,j->ij", self.costilts, xp.ones_like(self.costilts)), cos_tilt_2=xp.einsum("i,j->ji", self.costilts, xp.ones_like(self.costilts)), ) self.prior = PriorDict( dict( amax=Uniform(0.3, 1), alpha_chi=Uniform(1, 4), beta_chi=Uniform(1, 4), xi_spin=Uniform(0, 1), sigma_spin=Uniform(0, 4), ) ) self.n_test = 100
def get_priors(self, data): priors = PriorDict() # Set up the TOA prior if self.toa_prior_width < 1: if self.toa_prior_time == "auto": t0 = data.estimate_pulse_time() else: t0 = data.start + float(self.toa_prior_time) * data.duration dt = data.duration * self.toa_prior_width priors[self.toa_key] = Uniform( t0 - dt, t0 + dt, self.toa_key, latex_label=self.toa_latex_label) else: priors[self.toa_key] = Uniform( data.start, data.end, self.toa_key, latex_label=self.toa_latex_label) # Set up the beta prior if self.beta_min is None: self.beta_min = data.time_step if self.beta_max is None: self.beta_max = data.duration if self.beta_type == "uniform": priors[self.beta_key] = Uniform( self.beta_min, self.beta_max, self.beta_key, latex_label=self.beta_latex_label ) elif self.beta_type == "log-uniform": priors[self.beta_key] = LogUniform( self.beta_min, self.beta_max, self.beta_key, latex_label=self.beta_latex_label ) else: raise ValueError() # Set up the coefficient prior for key in self.coef_keys: priors[key] = SpikeAndSlab( slab=Uniform(1e-20 * data.max_flux, self.c_max_multiplier * data.range_flux), name=key, mix=self.c_mix, ) return priors
def create_population_prior(pop_parameters, prior_path): """Remove tilt angle priors, replace with population priors""" prior = bilby.prior.PriorDict(filename=prior_path) for param in ['cos_tilt_1', 'cos_tilt_2', 'phi_12', 'theta_jn', 'phi_jl']: prior.pop(param) for i in [1, 12]: kwargs = dict(mu=1, minimum=-1, maximum=1) prior[f'cos_theta_{i}'] = TruncatedNormal( sigma=pop_parameters[f'sigma_{i}'], **kwargs) prior[f'phi_1'] = Uniform(name='phi_1', minimum=0, maximum=2 * np.pi, boundary='periodic') prior[f'phi_z_s12'] = Uniform(name='phi_z_s12', minimum=0, maximum=2 * np.pi, boundary='periodic') prior[f'incl'] = Uniform(name='incl', minimum=0, maximum=2 * np.pi, boundary='periodic') return prior
def get_priors(self, data): priors = PriorDict() name = f'{self.basename}0' priors[name] = Uniform( 0, data.max_flux, name, latex_label='$B_{0}$') for ii in range(1, self.n_polynomials): name = f'{self.basename}{ii}' priors[name] = Normal( 0, data.range_flux / data.duration ** ii / np.math.factorial(ii), name, latex_label=f'$B_{{{ii}}}$') return priors
def setUp(self): self.ms = np.linspace(3, 100, 1000) self.dm = self.ms[1] - self.ms[0] m1s_grid, m2s_grid = xp.meshgrid(self.ms, self.ms) self.dataset = dict(mass_1=m1s_grid, mass_2=m2s_grid) self.power_prior = PriorDict() self.power_prior["alpha"] = Uniform(minimum=-4, maximum=12) self.power_prior["beta"] = Uniform(minimum=-4, maximum=12) self.power_prior["mmin"] = Uniform(minimum=3, maximum=10) self.power_prior["mmax"] = Uniform(minimum=40, maximum=100) self.gauss_prior = PriorDict() self.gauss_prior["lam"] = Uniform(minimum=0, maximum=1) self.gauss_prior["mpp"] = Uniform(minimum=20, maximum=60) self.gauss_prior["sigpp"] = Uniform(minimum=0, maximum=10) self.n_test = 10
def setUp(self): self.m1s = np.linspace(3, 100, 1000) self.qs = np.linspace(0.01, 1, 500) m1s_grid, qs_grid = xp.meshgrid(self.m1s, self.qs) self.dataset = dict(mass_1=m1s_grid, mass_ratio=qs_grid) self.power_prior = PriorDict() self.power_prior["alpha"] = Uniform(minimum=-4, maximum=12) self.power_prior["beta"] = Uniform(minimum=-4, maximum=12) self.power_prior["mmin"] = Uniform(minimum=3, maximum=10) self.power_prior["mmax"] = Uniform(minimum=40, maximum=100) self.gauss_prior = PriorDict() self.gauss_prior["lam"] = Uniform(minimum=0, maximum=1) self.gauss_prior["mpp"] = Uniform(minimum=20, maximum=60) self.gauss_prior["sigpp"] = Uniform(minimum=0, maximum=10) self.n_test = 10
def test_wrong_likelihood(self): """ Test with a bad likelihood name. """ het = HeterodynedData(self.data, times=self.times, detector=self.detector, par=self.parfile) priors = dict() priors["h0"] = Uniform(0.0, 1.0e-23, "h0") with pytest.raises(ValueError): _ = TargetedPulsarLikelihood(het, PriorDict(priors), likelihood="blah")
def test_priors(self): """ Test the parsed priors. """ # bad priors (unexpected parameter names) priors = dict() priors["a"] = Uniform(0.0, 1.0, "blah") priors["b"] = 2.0 het = HeterodynedData(self.data, times=self.times, detector=self.detector, par=self.parfile) with pytest.raises(ValueError): _ = TargetedPulsarLikelihood(het, PriorDict(priors))
def setUp(self): self.m1s = np.linspace(3, 100, 1000) self.qs = np.linspace(0.01, 1, 500) self.dm = self.m1s[1] - self.m1s[0] self.dq = self.qs[1] - self.qs[0] m1s_grid, qs_grid = xp.meshgrid(self.m1s, self.qs) self.dataset = dict(mass_1=m1s_grid, mass_ratio=qs_grid) self.power_prior = PriorDict() self.power_prior['alpha'] = Uniform(minimum=-4, maximum=12) self.power_prior['beta'] = Uniform(minimum=-4, maximum=12) self.power_prior['mmin'] = Uniform(minimum=3, maximum=10) self.power_prior['mmax'] = Uniform(minimum=30, maximum=100) self.gauss_prior = PriorDict() self.gauss_prior['lam'] = Uniform(minimum=0, maximum=1) self.gauss_prior['mpp'] = Uniform(minimum=20, maximum=60) self.gauss_prior['sigpp'] = Uniform(minimum=0, maximum=10) self.smooth_prior = PriorDict() self.smooth_prior['delta_m'] = Uniform(minimum=0, maximum=10) self.n_test = 10
def setUp(self): self.m1s = np.linspace(3, 100, 1000) self.qs = np.linspace(0.01, 1, 500) m1s_grid, qs_grid = xp.meshgrid(self.m1s, self.qs) self.dataset = dict(mass_1=m1s_grid, mass_ratio=qs_grid) self.power_prior = PriorDict() self.power_prior["alpha_1"] = Uniform(minimum=-4, maximum=12) self.power_prior["alpha_2"] = Uniform(minimum=-4, maximum=12) self.power_prior["beta"] = Uniform(minimum=-4, maximum=12) self.power_prior["mmin"] = Uniform(minimum=3, maximum=10) self.power_prior["mmax"] = Uniform(minimum=40, maximum=100) self.power_prior["break_fraction"] = Uniform(minimum=40, maximum=100) self.n_test = 10
def test_likelihood_null_likelihood(self): """ Test likelihood and null likelihood. """ het = HeterodynedData(self.data, times=self.times, detector=self.detector, par=self.parfile) priors = dict() priors["h0"] = Uniform(0.0, 1.0e-23, "h0") for likelihood in ["gaussian", "studentst"]: like = TargetedPulsarLikelihood(het, PriorDict(priors), likelihood=likelihood) like.parameters = {"h0": 0.0} assert like.log_likelihood() == like.noise_log_likelihood()
def test_deltafunction(self): """ Test the DeltaFunctionDistribution class. """ name = "test" dist = DeltaFunctionDistribution(name, peak=1.0) assert dist["peak"] == 1.0 assert dist.fixed["peak"] is True assert np.all(dist.sample(size=10) == 1.0) dist = DeltaFunctionDistribution(name, peak=Uniform(0.0, 1.0, "peak")) value = 0.1 hyper = {"peak": 0.5} assert isinstance(dist["peak"], Uniform) assert dist.fixed["peak"] is False assert dist.log_pdf(value, hyper) == -np.inf assert np.exp(dist.log_pdf(value, hyper)) == dist.pdf(value, hyper) value = 0.5 assert dist.log_pdf(value, hyper) == 0.0 assert np.exp(dist.log_pdf(value, hyper)) == dist.pdf(value, hyper) # check drawn sample is within bounds assert dist.low < dist.sample(hyper) < dist.high # draw multiple samples N = 100 samples = dist.sample(hyper, size=N) assert len(samples) == N assert np.all((samples > dist.low) & (samples < dist.high)) value = 1.0 hyper = {"kgsdg": 0.5} with pytest.raises(KeyError): dist.log_pdf(value, hyper)
h0range = [0.0, 1e-23] # set prior for lalapps_pulsar_parameter_estimation_nested priorfile = os.path.join(outdir, "{}_prior.txt".format(label)) priorcontent = """H0 uniform {} {} PHI0 uniform {} {} PSI uniform {} {} COSIOTA uniform {} {} """ with open(priorfile, "w") as fp: fp.write( priorcontent.format(*(h0range + phi0range + psirange + cosiotarange))) # set prior for bilby priors = OrderedDict() priors["h0"] = Uniform(h0range[0], h0range[1], "h0", latex_label=r"$h_0$") priors["phi0"] = Uniform(phi0range[0], phi0range[1], "phi0", latex_label=r"$\phi_0$", unit="rad") priors["psi"] = Uniform(psirange[0], psirange[1], "psi", latex_label=r"$\psi$", unit="rad") priors["cosiota"] = Uniform(cosiotarange[0], cosiotarange[1], "cosiota", latex_label=r"$\cos{\iota}$")
def get_prior(): return PriorDict( dict(cos_tilt_1=Uniform(-1, 1, "cos_tilt_1", r"$\cos\theta_{1}$"), cos_theta_12=Uniform(-1, 1, "cos_theta_12", r"$\cos\theta_{12}$")))
C22 uniform {} {} PHI21 uniform {} {} PHI22 uniform {} {} PSI uniform {} {} COSIOTA uniform {} {} """ with open(priorfile, "w") as fp: fp.write( priorcontent.format( *(c21range + c22range + phi21range + phi22range + psirange + cosiotarange) ) ) # set prior for bilby priors = OrderedDict() priors["c21"] = Uniform(c21range[0], c21range[1], "c21", latex_label=r"$C_{21}$") priors["c22"] = Uniform(c22range[0], c22range[1], "c22", latex_label=r"$C_{22}$") priors["phi21"] = Uniform( phi21range[0], phi21range[1], "phi21", latex_label=r"$\Phi_{21}$", unit="rad" ) priors["phi22"] = Uniform( phi22range[0], phi22range[1], "phi22", latex_label=r"$\Phi_{22}$", unit="rad" ) priors["psi"] = Uniform( psirange[0], psirange[1], "psi", latex_label=r"$\psi$", unit="rad" ) priors["cosiota"] = Uniform( cosiotarange[0], cosiotarange[1], "cosiota", latex_label=r"$\cos{\iota}$" ) # run lalapps_pulsar_parameter_estimation_nested