def test_without_simcov(self):
simdict = Simulations()
meadict = Measurements()
covdict = Covariances()
# mock measurements
arr_a = np.random.rand(1, 4*mpisize)
comm.Bcast(arr_a, root=0)
mea = Observable(arr_a, 'measured')
meadict.append(name=('test', None, 4*mpisize, None),
data=mea, otype='plain')
# mock covariance
arr_c = np.random.rand(4, 4*mpisize)
cov = Observable(arr_c, 'covariance')
covdict.append(name=('test', None, 4*mpisize, None),
cov_data=cov)
# mock observable with repeated single realisation
arr_b = np.random.rand(1, 4*mpisize)
comm.Bcast(arr_b, root=0)
arr_ens = np.zeros((2, 4*mpisize))
for i in range(len(arr_ens)):
arr_ens[i] = arr_b
sim = Observable(arr_ens, 'simulated')
simdict.append(name=('test', None, 4*mpisize, None),
data=sim, otype='plain')
# simplelikelihood
lh_simple = SimpleLikelihood(meadict, covdict)
rslt_simple = lh_simple(simdict)
# ensemblelikelihood
lh_ensemble = EnsembleLikelihood(meadict, covdict)
rslt_ensemble = lh_ensemble(simdict)
assert rslt_ensemble == rslt_simple
def test_diag(self):
simdict = Simulations()
meadict = Measurements()
covdict = Covariances()
# mock measurements
arr_a = np.random.rand(1, 40)
mea = Observable(arr_a, 'measured')
meadict.append(name=('test', None, 40, None),
data=mea, otype='plain')
# mock (diagonal) covariance
arr_var = np.random.rand(40)
cov = Observable(np.diag(arr_var), 'covariance')
covdict.append(name=('test', None, 40, None),
cov_data=cov)
# mock observable
arr_ens = np.random.rand(10, 40)
sim = Observable(arr_ens, 'simulated')
simdict.append(name=('test', None, 40, None),
data=sim, otype='plain')
# ensemblelikelihood + diagonal_covcov
lh_ens = EnsembleLikelihood(meadict, covdict, cov_func=diagonal_mcov)
result_ens = lh_ens(simdict)
# EnsembleLikelihoodDiagonal
lh_diag = EnsembleLikelihoodDiagonal(meadict, covdict)
result_diag = lh_diag(simdict)
assert np.allclose(result_diag, result_ens)
def test_with_cov(self):
simdict = Simulations()
meadict = Measurements()
covdict = Covariances()
# mock measurements
arr_a = np.random.rand(1, 4*mpisize)
comm.Bcast(arr_a, root=0)
mea = Observable(arr_a, 'measured')
meadict.append(name=('test', None, 4*mpisize, None),
data=mea, otype='plain')
# mock sims
arr_b = np.random.rand(5, 4*mpisize)
sim = Observable(arr_b, 'simulated')
simdict.append(name=('test', None, 4*mpisize, None),
data=sim, otype='plain')
# mock covariance
arr_c = np.random.rand(4, 4*mpisize)
cov = Observable(arr_c, 'covariance')
covdict.append(name=('test', None, 4*mpisize, None),
cov_data=cov)
# with covariance
lh = SimpleLikelihood(meadict, covdict)
# calc by likelihood
rslt = lh(simdict) # feed variable value, not parameter value
# calc by hand
full_b = np.vstack(comm.allgather(arr_b)) # global arr_b
diff = (np.mean(full_b, axis=0) - arr_a)
full_cov = np.vstack(comm.allgather(arr_c)) # global covariance
(sign, logdet) = np.linalg.slogdet(full_cov*2.*np.pi)
baseline = -0.5*(np.vdot(diff, np.linalg.solve(full_cov, diff.T))+sign*logdet)
assert np.allclose(rslt, baseline)
def test_with_trace_approximation(self):
simdict = Simulations()
meadict = Measurements()
covdict = Covariances()
# mock measurements
arr_a = np.random.rand(1, 4*mpisize)
comm.Bcast(arr_a, root=0)
mea = Observable(arr_a, 'measured')
meadict.append(name=('test', None, 4*mpisize, None),
data=mea, otype='plain')
# mock covariance (NB for the trace approximation to work, the data
# covariance needs to be diagonal)
arr_c = np.diag(np.random.rand(4))
cov = Observable(arr_c, 'covariance')
covdict.append(name=('test', None, 4*mpisize, None),
cov_data=cov)
# mock observable with repeated single realisation
arr_b = np.random.rand(1, 4*mpisize)
comm.Bcast(arr_b, root=0)
arr_ens = np.zeros((2, 4*mpisize))
for i in range(len(arr_ens)):
arr_ens[i] = arr_b
sim = Observable(arr_ens, 'simulated')
simdict.append(name=('test', None, 4*mpisize, None),
data=sim, otype='plain')
# simplelikelihood
lh_simple = SimpleLikelihood(meadict, covdict)
result_simple = lh_simple(simdict)
# ensemblelikelihood
lh_ensemble = EnsembleLikelihood(meadict, covdict,
use_trace_approximation=True)
result_ensemble = lh_ensemble(simdict)
assert result_ensemble == result_simple
def test_covdict_apply_mask(self):
msk = np.random.randint(0, 2, 2 * mpisize).reshape(1, -1)
mskdict = Masks()
comm.Bcast(msk, root=0)
mskdict.append(name=('test', None, 2 * mpisize, None),
data=msk,
otype='plain')
cov = np.random.rand(2, 2 * mpisize)
covdict = Covariances()
covdict.append(name=('test', None, 2 * mpisize, None), cov_data=cov)
covdict = mskdict(covdict)
pix_num = msk.sum()
assert ('test', None, pix_num, None) in covdict.keys()
def test_covdict_append_observable(self):
cov = Observable(np.random.rand(2, 2 * mpisize), 'covariance')
covdict = Covariances()
covdict.append(name=('test', None, 2 * mpisize, None),
cov_data=cov) # plain covariance
assert np.allclose(covdict[('test', None, 2 * mpisize, None)].data,
cov.data)
cov = Observable(np.random.rand(12 * mpisize, 12 * mpisize * mpisize),
'covariance')
covdict.append(name=('test', None, mpisize, None),
cov_data=cov) # healpix covariance
assert np.allclose(covdict[('test', None, mpisize, None)].data,
cov.data)
def test_covdict_append_array(self):
cov = np.random.rand(2, 2 * mpisize)
covdict = Covariances()
covdict.append(name=('test', None, 2 * mpisize, None),
cov_data=cov) # plain covariance
assert covdict[('test', None, 2 * mpisize,
None)].shape == (2 * mpisize, 2 * mpisize)
assert np.allclose(covdict[('test', None, 2 * mpisize, None)].data,
cov)
cov = np.random.rand(12 * mpisize, 12 * mpisize * mpisize)
covdict.append(name=('test', None, mpisize, None),
cov_data=cov) # healpix covariance
assert covdict[('test', None, mpisize,
None)].shape == (12 * mpisize * mpisize,
12 * mpisize * mpisize)
assert np.allclose(covdict[('test', None, mpisize, None)].data, cov)
def tutorial_one():
# Package imports
from imagine.fields import (
CosThermalElectronDensityFactory, NaiveGaussianMagneticFieldFactory,
UniformGrid)
from imagine.likelihoods import EnsembleLikelihood
from imagine.observables import Covariances, Measurements, TabularDataset
from imagine.pipelines import UltranestPipeline
from imagine.priors import FlatPrior
from imagine.simulators import TestSimulator
# IMAGINE-PRISM imports
from imagine_prism import PRISMPipeline
# Obtain data
data = get_mock_data()
# Create dataset
mock_dataset = TabularDataset(data, name='test', data_col='meas',
err_col='err')
# Create measurements and covariances objects
mock_data = Measurements(mock_dataset)
mock_cov = Covariances(mock_dataset)
# Create grid
grid = UniformGrid(box=[[0, 2*np.pi]*apu.kpc,
[0, 0]*apu.kpc,
[0, 0]*apu.kpc],
resolution=[30, 1, 1])
# Create factory for electron density field
ne_factory = CosThermalElectronDensityFactory(grid=grid)
ne_factory.default_parameters = {'a': 1*apu.rad/apu.kpc,
'beta': np.pi/2*apu.rad,
'gamma': np.pi/2*apu.rad}
# Create factory for magnetic field
B_factory = NaiveGaussianMagneticFieldFactory(grid=grid)
B_factory.active_parameters = ('a0', 'b0')
B_factory.priors = {'a0': FlatPrior(*[-5, 5]*apu.microgauss),
'b0': FlatPrior(*[0, 10]*apu.microgauss)}
# Combine factories together
factories = [ne_factory, B_factory]
# Create simulator
simulator = TestSimulator(mock_data)
# Create likelihood
likelihood = EnsembleLikelihood(mock_data, mock_cov)
# Create pipeline
img_pipe = UltranestPipeline(simulator=simulator,
factory_list=factories,
likelihood=likelihood,
ensemble_size=150)
# Create PRISMPipeline object
pipe = PRISMPipeline(img_pipe, root_dir='tests', working_dir='imagine_1')
# Return pipe
return(pipe)