def test_rotate_periodicity(self):
ds = directions.directions_factory(self.n, self.dim,
aligned_flag=False, rng=self.rng)
dth = np.full([ds.n], np.pi / 2.0)
for i in range(4):
ds.rotate(dth)
self.assertTrue(np.allclose(ds.u_0, ds.u))
def agents_factory(rng, dim, aligned_flag,
n=None, rho_0=None,
chi=None, onesided_flag=None,
tumble_flag=None, p_0=None, tumble_chemo_flag=None,
rotation_flag=None, Dr_0=None, rotation_chemo_flag=None,
temporal_chemo_flag=None, dt_mem=None, t_mem=None, time=None,
spatial_flag=None, v_0=None,
periodic_flag=None, L=None, origin_flags=None, obstructor=None,
c_field_flag=None, c_field=None):
if rho_0 is not None:
try:
volume_free = obstructor.volume_free
except AttributeError:
volume_free = np.product(L)
n = int(round(rho_0 * volume_free))
ds = directions_factory(n, dim, aligned_flag=aligned_flag,
rng=rng)
ps = positions_factory(spatial_flag, periodic_flag, n, dim, L,
origin_flags, rng, obstructor)
rudder_sets = rudder_set_factory(temporal_chemo_flag,
ds,
ps, v_0, dt_mem, t_mem, time,
c_field_flag, c_field,
onesided_flag, chi,
tumble_flag, p_0, tumble_chemo_flag,
rotation_flag, Dr_0, dim, rotation_chemo_flag)
swims = swimmers_factory(spatial_flag, v_0, ds)
return Agents(ds, ps, rudder_sets, swims)
def test_rotate_idempotence(self):
ds = directions.directions_factory(self.n, self.dim,
aligned_flag=False, rng=self.rng)
dth = self.rng.uniform(-np.pi, np.pi, size=self.n)
ds.rotate(dth)
ds.rotate(-dth)
self.assertTrue(np.allclose(ds.u_0, ds.u))
def test_tumble_coverage(self):
n = 2000
ds = directions.directions_factory(n, self.dim,
aligned_flag=False, rng=self.rng)
tumblers = np.ones([ds.n], dtype=np.bool)
ds.tumble(tumblers)
frac_close = np.isclose(ds.u_0, ds.u).sum() / float(ds.n)
self.assertAlmostEqual(frac_close, 0.5, 1)
def test_tumble_magnitude_conservation(self):
ds = directions.directions_factory(self.n, self.dim,
aligned_flag=False, rng=self.rng)
mags_0 = np.sum(np.square(ds.u))
tumblers = self.rng.choice([True, False], size=ds.n)
ds.tumble(tumblers)
mags_rot = np.sum(np.square(ds.u))
self.assertTrue(np.allclose(mags_0, mags_rot))
def test_rotate_magnitude_conservation(self):
ds = directions.directions_factory(self.n, self.dim,
aligned_flag=False, rng=self.rng)
mags_0 = np.sum(np.square(ds.u))
dth = self.rng.uniform(-np.pi, np.pi, size=self.n)
ds.rotate(dth)
mags_rot = np.sum(np.square(ds.u))
self.assertTrue(np.allclose(mags_0, mags_rot))
def get_ds(npy_seed):
rng = np.random.RandomState(rng_seed)
np.random.seed(npy_seed)
ds = directions.directions_factory(n, self.dim, aligned_flag=True)
ruds = self.rudders_cls(self.noise_measurer)
for _ in range(num_iterations):
ruds.rotate(ds, self.dt, rng)
return ds
def test_tumble_rate(self):
n = 2000
dt = 1.0
p = self.rng.uniform(0.0, 1.0, size=n)
noise_measurer = noise_measurers.NoiseMeasurer(p)
n_expected = (p * dt).sum()
# In 1D is a half chance to tumble back to the same direction.
if self.dim == 1:
n_expected /= 2.0
ds = directions.directions_factory(n, self.dim, aligned_flag=False,
rng=self.rng)
ruds = rudders.TumbleRudders(noise_measurer)
ruds.rotate(ds, dt, self.rng)
u_change = np.not_equal(ds.u_0, ds.u)
n_actual = np.any(u_change, axis=-1).sum()
err = np.abs(n_expected - n_actual) / n_expected
self.assertTrue(err < 0.05)
def test_rudder_autocorrelation(self):
n = 10000
t_max = 0.5
ds = directions.directions_factory(n, self.dim, aligned_flag=True)
rudders = self.rudders_cls(self.noise_measurer)
u_0 = ds.u
ts = np.arange(0.0, t_max, self.dt)
mean_dots = []
for t in ts:
rudders.rotate(ds, self.dt, self.rng)
mean_dot = np.mean(np.sum(u_0 * ds.u, axis=-1))
mean_dots.append(mean_dot)
def exp(t, t_rot):
return np.exp(-t / t_rot)
popt, pcov = curve_fit(exp, ts, mean_dots)
t_rot_actual = popt[0]
self.assertAlmostEqual(t_rot_actual, self.t_rot_expect, 1)
def test_rotate_identity(self):
ds = directions.directions_factory(self.n, self.dim,
aligned_flag=False, rng=self.rng)
dth = np.zeros([ds.n])
ds.rotate(dth)
self.assertTrue(np.allclose(ds.u_0, ds.u))
def test_tumble_coverage(self):
ds = directions.directions_factory(self.n, self.dim,
aligned_flag=False, rng=self.rng)
tumblers = np.ones([ds.n], dtype=np.bool)
ds.tumble(tumblers, rng=self.rng)
self.assertFalse(np.any(np.isclose(ds.u_0, ds.u)))
def test_tumble_identity(self):
ds = directions.directions_factory(self.n, self.dim,
aligned_flag=False, rng=self.rng)
tumblers = np.zeros([ds.n], dtype=np.bool)
ds.tumble(tumblers)
self.assertTrue(np.allclose(ds.u_0, ds.u))
