def interp(self, dx, p, dx_PGD, ax, ap, ai, af):
di, df = self.cosmo.comoving_distance(
1. / numpy.array([ai, af], dtype=float) - 1.)
zero_map = Literal(self.mappm.create('real', value=0.))
kmaps = [zero_map for ii in range(len(self.ds))]
for M in self.imgen.generate(di, df):
# if lower end of box further away than source -> do nothing
if df > self.max_ds:
continue
else:
M, boxshift = M
# positions of unevolved particles after rotation
d_approx = self.rotate.build(M=M, boxshift=boxshift).compute(
'd', init=dict(x=self.q))
z_approx = z_chi.apl.impl(node=None,
cosmo=self.cosmo,
z_chi_int=self.z_chi_int,
chi=d_approx)['z']
a_approx = 1. / (z_approx + 1.)
# move particles to a_approx, then add PGD correction
dx1 = dx + p * self.DriftFactor(a_approx, ax,
ap)[:, None] + dx_PGD
# rotate their positions
xy, d = self.rotate((dx1 + self.q) % self.pm.BoxSize, M,
boxshift)
# projection
xy = ((xy - self.pm.BoxSize[:2] * 0.5) /
linalg.broadcast_to(linalg.reshape(d, (len(self.q), 1)),
(len(self.q), 2)) +
self.mappm.BoxSize * 0.5)
for ii, ds in enumerate(self.ds):
w = self.wlen(d, ds)
mask = stdlib.eval(
d,
lambda d, di=di, df=df, ds=ds, d_approx=d_approx: 1.0 *
(d_approx < di) * (d_approx >= df) * (d <= ds))
kmap_ = self.makemap(xy, w * mask) * self.factor
kmaps[ii] = kmaps[ii] + kmap_
return kmaps
def model(self, x):
di, df = self.cosmo.comoving_distance(1. /
numpy.array([self.ai, self.af]) -
1.)
kmap = lightcone.list_elem(self.kmaps, 0)
for M in self.sim.imgen.generate(di, df):
#if lower end of box further away than source -> do nothing
if df > self.sim.max_ds:
continue
else:
M, boxshift = M
#positions of unevolved particles after rotation
d_approx = self.sim.rotate.build(
M=M, boxshift=boxshift).compute('d', init=dict(x=self.q))
z_approx = lightcone.z_chi.apl.impl(
node=None,
cosmo=self.cosmo,
z_chi_int=self.sim.z_chi_int,
chi=d_approx)['z']
a_approx = 1. / (z_approx + 1.)
#move particles to a_approx, then add PGD correction
dx1 = x + self.p * self.DriftFactor(
a_approx, self.ac, self.ac)[:, None] + self.dx_PGD
#rotate their positions
xy, d = self.sim.rotate((dx1 + self.q) % self.pm.BoxSize, M,
boxshift)
#projection
xy = (xy - self.pm.BoxSize[:2] * 0.5) / linalg.broadcast_to(
linalg.reshape(d, (np.prod(self.pm.Nmesh), 1)),
(np.prod(self.pm.Nmesh), 2)) + self.sim.mappm.BoxSize * 0.5
for ii, ds in enumerate(self.sim.ds):
w = self.sim.wlen(d, ds)
mask = stdlib.eval(
d,
lambda d, di=di, df=df, ds=ds, d_approx=d_approx: 1.0 *
(d_approx < di) * (d_approx >= df) * (d <= ds))
#kmap = lightcone.list_elem(self.kmaps,ii)
kmap_ = self.sim.makemap(xy, w * mask)
kmap = linalg.add(kmap_, kmap)
#self.kmaps = lightcone.list_put(self.kmaps,kmap,ii)
#kmap_ = RealField(lightcone.list_elem(self.kmaps,0))
return kmap
def no_interp(self, dx, p, dx_PGD, ai, af, jj):
dx = dx + dx_PGD
di, df = self.cosmo.comoving_distance(
1. / numpy.array([ai, af], dtype=object) - 1.)
zero_map = Literal(self.mappm.create('real', value=0.))
kmaps = [zero_map for ii in range(len(self.ds))]
for M in self.imgen.generate(di, df):
# if lower end of box further away than source -> do nothing
if df > self.max_ds:
if self.params['logging']:
self.logger.info('imgen passed, %d' % jj)
continue
else:
if self.params['logging']:
self.logger.info('imgen with projection, %d' % jj)
M, boxshift = M
xy, d = self.rotate((dx + self.q) % self.pm.BoxSize, M,
boxshift)
d_approx = self.rotate.build(M=M, boxshift=boxshift).compute(
'd', init=dict(x=self.q))
xy = ((xy - self.pm.BoxSize[:2] * 0.5) /
linalg.broadcast_to(linalg.reshape(d, (len(self.q), 1)),
(len(self.q), 2)) +
self.mappm.BoxSize * 0.5)
for ii, ds in enumerate(self.ds):
if self.params['logging']:
self.logger.info('projection, %d' % jj)
w = self.wlen(d, ds)
mask = stdlib.eval(
d,
lambda d, di=di, df=df, ds=ds, d_approx=d_approx: 1.0 *
(d_approx < di) * (d_approx >= df) * (d <= ds))
kmap_ = self.makemap(xy, w * mask) * self.factor
kmaps[ii] = kmaps[ii] + kmap_
return kmaps
def no_interp(self, kmaps, q, ai, af, jj):
di, df = self.cosmo.comoving_distance(
1. / numpy.array([ai, af], dtype=object) - 1.)
#q = np.random.random(self.q.shape)*self.pm.BoxSize[0]
for M in self.imgen.generate(di, df):
# if lower end of box further away than source -> do nothing
if df > self.max_ds:
if self.params['logging']:
self.logger.info('imgen passed, %d' % jj)
continue
else:
if self.params['logging']:
self.logger.info('imgen with projection, %d' % jj)
M, boxshift = M
xy, d = self.rotate(q, M, boxshift)
d_approx = self.rotate.build(M=M, boxshift=boxshift).compute(
'd', init=dict(x=q))
xy = ((xy - self.pm.BoxSize[:2] * 0.5) /
linalg.broadcast_to(linalg.reshape(d, (len(self.q), 1)),
(len(self.q), 2)) +
self.mappm.BoxSize * 0.5)
for ii, ds in enumerate(self.ds):
if self.params['logging']:
self.logger.info('projection, %d' % jj)
w = self.wlen(d, ds)
mask = stdlib.eval(
d,
lambda d, di=di, df=df, ds=ds, d_approx=d_approx: 1.0 *
(d_approx < di) * (d_approx >= df) * (d <= ds))
kmap_ = self.makemap(xy, w * mask) * self.factor
kmap = list_elem(kmaps, ii)
kmap = linalg.add(kmap_, kmap)
kmaps = list_put(kmaps, kmap, ii)
return kmaps
def model(self, x):
# testing contraction
a = linalg.reshape(x, (10, ))
b = linalg.reshape(x, (10))
return linalg.einsum("i, i->", [a, b])
def model(self, x):
# testing uncontracted dimensions
a = linalg.reshape(x, (10, 1, 1))
b = linalg.reshape(x, (1, 10))
return linalg.einsum("abc, ca->b", [a, b])
def model(self, x):
c = linalg.reshape(x, (5, 2))
return c
def model(self, x):
x = linalg.reshape(x, (5, 2))
return linalg.sum(x, axis=0)
def model(self, x):
result = self.a * linalg.broadcast_to(linalg.reshape(x, (5, 1)),
(5, 2))
return result