def test_noparticles_model_run_after_release_time(self):
"""
Tests that the spill doesn't release anything if the first call
to release elements is after the release time.
This so that if the user sets the model start time after the spill,
they don't get anything.
"""
sp = PointLineSource(num_elements=self.num_elements,
start_position=self.start_position,
release_time=self.release_time)
# Test no particles released for following conditions
# current_time > spill's release_time
# current_time + timedelta > spill's release_time
for rel_delay in range(1, 3):
num = sp.num_elements_to_release(self.release_time
+ timedelta(hours=rel_delay),
time_step=30 * 60)
#assert num is None
assert num == 0
# rewind and it should work
sp.rewind()
data_arrays = self.release_and_assert(sp, self.release_time, 30 * 60,
{}, self.num_elements)
assert np.alltrue(data_arrays['positions'] == self.start_position)
def test_cont_point_release(self):
"""
Time varying release so release_time < end_release_time. It releases
particles over 10 hours. start_position == end_position so it is still
a point source
It simulates how particles could be released by a Model with a variable
timestep
"""
sp = PointLineSource(num_elements=100,
start_position=self.start_position,
release_time=self.release_time,
end_release_time=self.release_time
+ timedelta(hours=10))
timestep = 3600 # one hour in seconds
"""
Release elements incrementally to test continuous release
4 times and timesteps over which elements are released. The timesteps
are variable
"""
# at exactly the release time -- ten get released at start_position
# one hour into release -- ten more released
# keep appending to data_arrays in same manner as SpillContainer would
# 1-1/2 hours into release - 5 more
# at end -- rest (75 particles) should be released
data_arrays = {}
delay_after_rel_time = [timedelta(hours=0),
timedelta(hours=1),
timedelta(hours=2),
timedelta(hours=10)]
ts = [timestep, timestep, timestep / 2, timestep]
exp_num_released = [10, 10, 5, 75]
for ix in range(4):
data_arrays = self.release_and_assert(sp,
self.release_time + delay_after_rel_time[ix],
ts[ix], data_arrays, exp_num_released[ix])
assert np.alltrue(data_arrays['positions'] == self.start_position)
assert sp.num_released == sp.num_elements
# rewind and reset data arrays for new release
sp.rewind()
data_arrays = {}
# 360 second time step: should release first LE
# In 3600 sec, 10 particles are released so one particle every 360sec
# release one particle each over (360, 720) seconds
for ix in range(2):
ts = ix * 360 + 360
data_arrays = self.release_and_assert(sp, self.release_time, ts,
data_arrays, 1)
assert np.alltrue(data_arrays['positions'] == self.start_position)
def test_inst_point_release(self):
"""
Test all particles for an instantaneous point release are released
correctly.
- also tests that once all particles have been released, no new
particles are released in subsequent steps
"""
sp = PointLineSource(num_elements=self.num_elements,
start_position=self.start_position,
release_time=self.release_time)
timestep = 3600 # seconds
# release all particles
data_arrays = self.release_and_assert(sp, self.release_time,
timestep, {}, self.num_elements)
assert np.alltrue(data_arrays['positions'] == self.start_position)
# no more particles to release since all particles have been released
num = sp.num_elements_to_release(self.release_time + timedelta(10),
timestep)
#assert num is None
assert num == 0
# reset and try again
sp.rewind()
assert sp.num_released == 0
num = sp.num_elements_to_release(self.release_time - timedelta(10),
timestep)
#assert num is None
assert num == 0
assert sp.num_released == 0
# release all particles
data_arrays = self.release_and_assert(sp, self.release_time,
timestep, {}, self.num_elements)
assert np.alltrue(data_arrays['positions'] == self.start_position)