def test_start_time():
model = Model()
st = datetime.now()
model.start_time = st
assert model.start_time == st
assert model.current_time_step == -1
model.step()
st = datetime(2012, 8, 12, 13)
model.start_time = st
assert model.current_time_step == -1
assert model.start_time == st
def test_start_time():
model = Model()
st = datetime.now()
model.start_time = st
assert model.start_time == st
assert model.current_time_step == -1
model.step()
st = datetime(2012, 8, 12, 13)
model.start_time = st
assert model.current_time_step == -1
assert model.start_time == st
def test_simple_run_with_map():
'''
pretty much all this tests is that the model will run
'''
start_time = datetime(2012, 9, 15, 12, 0)
model = Model()
model.map = gnome.map.MapFromBNA(testmap, refloat_halflife=6) # hours
a_mover = SimpleMover(velocity=(1., 2., 0.))
model.movers += a_mover
assert len(model.movers) == 1
spill = point_line_release_spill(num_elements=10,
start_position=(0., 0., 0.),
release_time=start_time)
model.spills += spill
assert len(model.spills) == 1
model.start_time = spill.release.release_time
# test iterator
for step in model:
print 'just ran time step: %s' % step
assert step['step_num'] == model.current_time_step
# reset and run again
model.reset()
# test iterator is repeatable
for step in model:
print 'just ran time step: %s' % step
assert step['step_num'] == model.current_time_step
def test_simple_run_with_image_output_uncertainty(tmpdir):
'''
Pretty much all this tests is that the model will run and output images
'''
images_dir = tmpdir.mkdir('Test_images2').strpath
if os.path.isdir(images_dir):
shutil.rmtree(images_dir)
os.mkdir(images_dir)
start_time = datetime(2012, 9, 15, 12, 0)
# the land-water map
gmap = gnome.map.MapFromBNA(testdata['MapFromBNA']['testmap'],
refloat_halflife=6) # hours
renderer = gnome.outputters.Renderer(testdata['MapFromBNA']['testmap'],
images_dir, size=(400, 300))
model = Model(start_time=start_time,
time_step=timedelta(minutes=15), duration=timedelta(hours=1),
map=gmap,
uncertain=True, cache_enabled=False,
)
model.outputters += renderer
a_mover = SimpleMover(velocity=(1., -1., 0.))
model.movers += a_mover
N = 10 # a line of ten points
start_points = np.zeros((N, 3), dtype=np.float64)
start_points[:, 0] = np.linspace(-127.1, -126.5, N)
start_points[:, 1] = np.linspace(47.93, 48.1, N)
# print start_points
release = SpatialRelease(start_position=start_points,
release_time=start_time)
model.spills += Spill(release)
# model.add_spill(spill)
model.start_time = release.release_time
# image_info = model.next_image()
model.uncertain = True
num_steps_output = 0
while True:
try:
image_info = model.step()
num_steps_output += 1
print image_info
except StopIteration:
print 'Done with the model run'
break
# there is the zeroth step, too.
calculated_steps = (model.duration.total_seconds() / model.time_step) + 1
assert num_steps_output == calculated_steps
def test_simple_run_with_image_output_uncertainty(tmpdir):
'''
Pretty much all this tests is that the model will run and output images
'''
images_dir = tmpdir.mkdir('Test_images2').strpath
if os.path.isdir(images_dir):
shutil.rmtree(images_dir)
os.mkdir(images_dir)
start_time = datetime(2012, 9, 15, 12, 0)
# the land-water map
gmap = gnome.map.MapFromBNA(testdata['MapFromBNA']['testmap'],
refloat_halflife=6) # hours
renderer = gnome.outputters.Renderer(testdata['MapFromBNA']['testmap'],
images_dir, size=(400, 300))
model = Model(start_time=start_time,
time_step=timedelta(minutes=15), duration=timedelta(hours=1),
map=gmap,
uncertain=True, cache_enabled=False,
)
model.outputters += renderer
a_mover = SimpleMover(velocity=(1., -1., 0.))
model.movers += a_mover
N = 10 # a line of ten points
start_points = np.zeros((N, 3), dtype=np.float64)
start_points[:, 0] = np.linspace(-127.1, -126.5, N)
start_points[:, 1] = np.linspace(47.93, 48.1, N)
# print start_points
release = SpatialRelease(start_position=start_points,
release_time=start_time)
model.spills += Spill(release)
# model.add_spill(spill)
model.start_time = release.release_time
# image_info = model.next_image()
model.uncertain = True
num_steps_output = 0
while True:
try:
image_info = model.step()
num_steps_output += 1
print image_info
except StopIteration:
print 'Done with the model run'
break
# there is the zeroth step, too.
calculated_steps = (model.duration.total_seconds() / model.time_step) + 1
assert num_steps_output == calculated_steps
def test_mover_api():
'''
Test the API methods for adding and removing movers to the model.
'''
start_time = datetime(2012, 1, 1, 0, 0)
model = Model()
model.duration = timedelta(hours=12)
model.time_step = timedelta(hours=1)
model.start_time = start_time
mover_1 = SimpleMover(velocity=(1., -1., 0.))
mover_2 = SimpleMover(velocity=(1., -1., 0.))
mover_3 = SimpleMover(velocity=(1., -1., 0.))
mover_4 = SimpleMover(velocity=(1., -1., 0.))
# test our add object methods
model.movers += mover_1
model.movers += mover_2
# test our get object methods
assert model.movers[mover_1.id] == mover_1
assert model.movers[mover_2.id] == mover_2
with raises(KeyError):
temp = model.movers['Invalid']
print temp
# test our iter and len object methods
assert len(model.movers) == 2
assert len([m for m in model.movers]) == 2
for (m1, m2) in zip(model.movers, [mover_1, mover_2]):
assert m1 == m2
# test our add objectlist methods
model.movers += [mover_3, mover_4]
assert [m for m in model.movers] == [mover_1, mover_2, mover_3, mover_4]
# test our remove object methods
del model.movers[mover_3.id]
assert [m for m in model.movers] == [mover_1, mover_2, mover_4]
with raises(KeyError):
# our key should also be gone after the delete
temp = model.movers[mover_3.id]
print temp
# test our replace method
model.movers[mover_2.id] = mover_3
assert [m for m in model.movers] == [mover_1, mover_3, mover_4]
assert model.movers[mover_3.id] == mover_3
with raises(KeyError):
# our key should also be gone after the delete
temp = model.movers[mover_2.id]
print temp
def test_mover_api():
'''
Test the API methods for adding and removing movers to the model.
'''
start_time = datetime(2012, 1, 1, 0, 0)
model = Model()
model.duration = timedelta(hours=12)
model.time_step = timedelta(hours=1)
model.start_time = start_time
mover_1 = SimpleMover(velocity=(1., -1., 0.))
mover_2 = SimpleMover(velocity=(1., -1., 0.))
mover_3 = SimpleMover(velocity=(1., -1., 0.))
mover_4 = SimpleMover(velocity=(1., -1., 0.))
# test our add object methods
model.movers += mover_1
model.movers += mover_2
# test our get object methods
assert model.movers[mover_1.id] == mover_1
assert model.movers[mover_2.id] == mover_2
with raises(KeyError):
temp = model.movers['Invalid']
print temp
# test our iter and len object methods
assert len(model.movers) == 2
assert len([m for m in model.movers]) == 2
for (m1, m2) in zip(model.movers, [mover_1, mover_2]):
assert m1 == m2
# test our add objectlist methods
model.movers += [mover_3, mover_4]
assert [m for m in model.movers] == [mover_1, mover_2, mover_3, mover_4]
# test our remove object methods
del model.movers[mover_3.id]
assert [m for m in model.movers] == [mover_1, mover_2, mover_4]
with raises(KeyError):
# our key should also be gone after the delete
temp = model.movers[mover_3.id]
print temp
# test our replace method
model.movers[mover_2.id] = mover_3
assert [m for m in model.movers] == [mover_1, mover_3, mover_4]
assert model.movers[mover_3.id] == mover_3
with raises(KeyError):
# our key should also be gone after the delete
temp = model.movers[mover_2.id]
print temp
def test_callback_add_mover():
'Test callback after add mover'
units = 'meter per second'
model = Model()
model.start_time = datetime(2012, 1, 1, 0, 0)
model.duration = timedelta(hours=10)
model.time_step = timedelta(hours=1)
# start_loc = (1.0, 2.0, 0.0) # random non-zero starting points
# add Movers
model.movers += SimpleMover(velocity=(1., -1., 0.))
series = np.array((model.start_time, (10, 45)),
dtype=datetime_value_2d).reshape((1, ))
model.movers += WindMover(Wind(timeseries=series, units=units))
# this should create a Wind object
new_wind = Wind(timeseries=series, units=units)
model.environment += new_wind
assert new_wind in model.environment
assert len(model.environment) == 2
tide_file = get_datafile(os.path.join(tides_dir, 'CLISShio.txt'))
tide_ = Tide(filename=tide_file)
d_file = get_datafile(os.path.join(lis_dir, 'tidesWAC.CUR'))
model.movers += CatsMover(d_file, tide=tide_)
model.movers += CatsMover(d_file)
for mover in model.movers:
assert mover.active_start == inf_datetime.InfDateTime('-inf')
assert mover.active_stop == inf_datetime.InfDateTime('inf')
if hasattr(mover, 'wind'):
assert mover.wind in model.environment
if hasattr(mover, 'tide'):
if mover.tide is not None:
assert mover.tide in model.environment
# Add a mover with user defined active_start / active_stop values
# - these should not be updated
active_on = model.start_time + timedelta(hours=1)
active_off = model.start_time + timedelta(hours=4)
custom_mover = SimpleMover(velocity=(1., -1., 0.),
active_start=active_on,
active_stop=active_off)
model.movers += custom_mover
assert model.movers[custom_mover.id].active_start == active_on
assert model.movers[custom_mover.id].active_stop == active_off
def test_callback_add_mover():
'Test callback after add mover'
units = 'meter per second'
model = Model()
model.start_time = datetime(2012, 1, 1, 0, 0)
model.duration = timedelta(hours=10)
model.time_step = timedelta(hours=1)
# start_loc = (1.0, 2.0, 0.0) # random non-zero starting points
# add Movers
model.movers += SimpleMover(velocity=(1., -1., 0.))
series = np.array((model.start_time, (10, 45)),
dtype=datetime_value_2d).reshape((1, ))
model.movers += WindMover(Wind(timeseries=series, units=units))
# this should create a Wind object
new_wind = Wind(timeseries=series, units=units)
model.environment += new_wind
assert new_wind in model.environment
assert len(model.environment) == 2
tide_ = Tide(filename=testdata['CatsMover']['tide'])
d_file = testdata['CatsMover']['curr']
model.movers += CatsMover(d_file, tide=tide_)
model.movers += CatsMover(d_file)
for mover in model.movers:
assert mover.active_start == inf_datetime.InfDateTime('-inf')
assert mover.active_stop == inf_datetime.InfDateTime('inf')
if hasattr(mover, 'wind'):
assert mover.wind in model.environment
if hasattr(mover, 'tide'):
if mover.tide is not None:
assert mover.tide in model.environment
# Add a mover with user defined active_start / active_stop values
# - these should not be updated
active_on = model.start_time + timedelta(hours=1)
active_off = model.start_time + timedelta(hours=4)
custom_mover = SimpleMover(velocity=(1., -1., 0.),
active_start=active_on,
active_stop=active_off)
model.movers += custom_mover
assert model.movers[custom_mover.id].active_start == active_on
assert model.movers[custom_mover.id].active_stop == active_off
def test_callback_add_mover():
""" Test callback after add mover """
units = 'meter per second'
model = Model()
model.time_step = timedelta(hours=1)
model.duration = timedelta(hours=10)
model.start_time = datetime(2012, 1, 1, 0, 0)
# start_loc = (1.0, 2.0, 0.0) # random non-zero starting points
# add Movers
model.movers += SimpleMover(velocity=(1., -1., 0.))
series = np.array((model.start_time, (10, 45)),
dtype=datetime_value_2d).reshape((1, ))
model.movers += WindMover(Wind(timeseries=series, units=units))
tide_file = get_datafile(os.path.join(os.path.dirname(__file__),
r"sample_data", 'tides', 'CLISShio.txt'))
tide_ = Tide(filename=tide_file)
d_file = get_datafile(os.path.join(datadir,
r"long_island_sound/tidesWAC.CUR"))
model.movers += CatsMover(d_file, tide=tide_)
model.movers += CatsMover(d_file)
for mover in model.movers:
assert mover.active_start == inf_datetime.InfDateTime('-inf')
assert mover.active_stop == inf_datetime.InfDateTime('inf')
if isinstance(mover, WindMover):
assert mover.wind.id in model.environment
if isinstance(mover, CatsMover):
if mover.tide is not None:
assert mover.tide.id in model.environment
# Add a mover with user defined active_start / active_stop values
# - these should not be updated
active_on = model.start_time + timedelta(hours=1)
active_off = model.start_time + timedelta(hours=4)
custom_mover = SimpleMover(velocity=(1., -1., 0.),
active_start=active_on,
active_stop=active_off)
model.movers += custom_mover
assert model.movers[custom_mover.id].active_start == active_on
assert model.movers[custom_mover.id].active_stop == active_off
def test_model_time_and_current_time_in_sc():
model = Model()
model.start_time = datetime.now()
assert model.current_time_step == -1
assert model.model_time == model.start_time
for step in range(4):
model.step()
assert model.current_time_step == step
assert (model.model_time ==
model.start_time + timedelta(seconds=step * model.time_step))
for sc in model.spills.items():
assert model.model_time == sc.current_time_stamp
def test_model_time_and_current_time_in_sc():
model = Model()
model.start_time = datetime.now()
assert model.current_time_step == -1
assert model.model_time == model.start_time
for step in range(4):
model.step()
assert model.current_time_step == step
assert (model.model_time == model.start_time +
timedelta(seconds=step * model.time_step))
for sc in model.spills.items():
assert model.model_time == sc.current_time_stamp
def test_simple_run_rewind():
'''
Pretty much all this tests is that the model will run
and the seed is set during first run, then set correctly
after it is rewound and run again
'''
start_time = datetime(2012, 9, 15, 12, 0)
model = Model()
model.map = gnome.map.GnomeMap()
a_mover = SimpleMover(velocity=(1., 2., 0.))
model.movers += a_mover
assert len(model.movers) == 1
spill = point_line_release_spill(num_elements=10,
start_position=(0., 0., 0.),
release_time=start_time)
model.spills += spill
assert len(model.spills) == 1
# model.add_spill(spill)
model.start_time = spill.release.release_time
# test iterator
for step in model:
print 'just ran time step: %s' % model.current_time_step
assert step['step_num'] == model.current_time_step
pos = np.copy(model.spills.LE('positions'))
# rewind and run again:
print 'rewinding'
model.rewind()
# test iterator is repeatable
for step in model:
print 'just ran time step: %s' % model.current_time_step
assert step['step_num'] == model.current_time_step
assert np.all(model.spills.LE('positions') == pos)
def test_simple_run_rewind():
'''
Pretty much all this tests is that the model will run
and the seed is set during first run, then set correctly
after it is rewound and run again
'''
start_time = datetime(2012, 9, 15, 12, 0)
model = Model()
model.map = gnome.map.GnomeMap()
a_mover = SimpleMover(velocity=(1., 2., 0.))
model.movers += a_mover
assert len(model.movers) == 1
spill = point_line_release_spill(num_elements=10,
start_position=(0., 0., 0.),
release_time=start_time)
model.spills += spill
assert len(model.spills) == 1
# model.add_spill(spill)
model.start_time = spill.release.release_time
# test iterator
for step in model:
print 'just ran time step: %s' % model.current_time_step
assert step['step_num'] == model.current_time_step
pos = np.copy(model.spills.LE('positions'))
# rewind and run again:
print 'rewinding'
model.rewind()
# test iterator is repeatable
for step in model:
print 'just ran time step: %s' % model.current_time_step
assert step['step_num'] == model.current_time_step
assert np.all(model.spills.LE('positions') == pos)
def test_callback_add_mover_midrun():
'Test callback after add mover called midway through the run'
model = Model()
model.start_time = datetime(2012, 1, 1, 0, 0)
model.duration = timedelta(hours=10)
model.time_step = timedelta(hours=1)
# start_loc = (1.0, 2.0, 0.0) # random non-zero starting points
# model = setup_simple_model()
for i in range(2):
model.step()
assert model.current_time_step > -1
# now add another mover and make sure model rewinds
model.movers += SimpleMover(velocity=(2., -2., 0.))
assert model.current_time_step == -1
def test_callback_add_mover_midrun():
'Test callback after add mover called midway through the run'
model = Model()
model.start_time = datetime(2012, 1, 1, 0, 0)
model.duration = timedelta(hours=10)
model.time_step = timedelta(hours=1)
# start_loc = (1.0, 2.0, 0.0) # random non-zero starting points
# model = setup_simple_model()
for i in range(2):
model.step()
assert model.current_time_step > -1
# now add another mover and make sure model rewinds
model.movers += SimpleMover(velocity=(2., -2., 0.))
assert model.current_time_step == -1
def test_simple_run_with_map():
"""
pretty much all this tests is that the model will run
"""
start_time = datetime(2012, 9, 15, 12, 0)
model = Model()
model.map = gnome.map.MapFromBNA(testmap, refloat_halflife=6) # hours
a_mover = SimpleMover(velocity=(1., 2., 0.))
model.movers += a_mover
assert len(model.movers) == 1
spill = PointLineSource(num_elements=10,
start_position=(0., 0., 0.), release_time=start_time)
model.spills += spill
# model.add_spill(spill)
assert len(model.spills) == 1
model.start_time = spill.release_time
# test iterator:
for step in model:
print 'just ran time step: %s' % step
# reset and run again:
model.reset()
# test iterator:
for step in model:
print 'just ran time step: %s' % step
assert True
def test_simple_run_with_map():
'''
pretty much all this tests is that the model will run
'''
start_time = datetime(2012, 9, 15, 12, 0)
model = Model()
model.map = gnome.map.MapFromBNA(testdata['MapFromBNA']['testmap'],
refloat_halflife=6) # hours
a_mover = SimpleMover(velocity=(1., 2., 0.))
model.movers += a_mover
assert len(model.movers) == 1
spill = point_line_release_spill(num_elements=10,
start_position=(0., 0., 0.),
release_time=start_time)
model.spills += spill
assert len(model.spills) == 1
model.start_time = spill.release.release_time
# test iterator
for step in model:
print 'just ran time step: %s' % step
assert step['step_num'] == model.current_time_step
# reset and run again
model.reset()
# test iterator is repeatable
for step in model:
print 'just ran time step: %s' % step
assert step['step_num'] == model.current_time_step
def main(RootDir, Data_Dir, StartSite, RunSite, NumStarts, RunStarts,
ReleaseLength, TrajectoryRunLength, StartTimeFiles, TrajectoriesPath,
NumLEs, MapFileName, refloat, current_files, wind_files,
diffusion_coef, model_timestep, windage_range, windage_persist,
OutputTimestep):
timingRecord = open(os.path.join(RootDir, "timing.txt"), "w")
count = len(StartTimeFiles) * len(RunStarts)
timingRecord.write("This file tracks the time to process " + str(count) +
" gnome runs")
# model timing
release_duration = timedelta(hours=ReleaseLength)
run_time = timedelta(hours=TrajectoryRunLength)
# initiate model
model = Model(duration=run_time, time_step=model_timestep, uncertain=False)
# determine boundary for model
print "Adding the map:", MapFileName
mapfile = get_datafile(os.path.join(Data_Dir, MapFileName))
# model.map = MapFromBNA(mapfile, refloat_halflife=refloat) no, model map needs to inclde mudflats. later
# loop through seasons
for Season in StartTimeFiles:
timer1 = datetime.now()
SeasonName = Season[1]
start_times = open(Season[0], 'r').readlines()[:NumStarts]
SeasonTrajDir = os.path.join(RootDir, TrajectoriesPath, SeasonName)
if not os.path.isdir(SeasonTrajDir):
print "Creating directory: ", SeasonTrajDir
make_dir(SeasonTrajDir)
print " Season:", SeasonName
# get and parse start times in this season
start_dt = []
for start_time in start_times:
start_time = [int(i) for i in start_time.split(',')]
start_time = datetime(start_time[0], start_time[1], start_time[2],
start_time[3], start_time[4])
start_dt.append(start_time)
## loop through start times
for time_idx in RunStarts:
timer2 = datetime.now()
gc.collect()
model.movers.clear()
## set the start location
start_time = start_dt[time_idx]
end_time = start_time + run_time
model.start_time = start_time
print " ", start_time, "to", end_time
## get a list of the only data files needed for the start time (less data used)
## note: requires data files in year increments
#Todo: needs fixing before real run
years = range(start_time.year, end_time.year + 1)
years = [str(i) for i in years]
wind = [s for s in wind_files if any(xs in s for xs in years)]
current = [
s for s in current_files if any(xs in s for xs in years)
]
#Todo: add mudflats. Does it work like this?
topology = {'node_lon': 'x', 'node_lat': 'y'}
## add wind movers
w_mover = PyWindMover(filename=wind)
model.movers += w_mover
## add current movers
current_mover = gs.GridCurrent.from_netCDF(current,
grid_topology=topology)
c_mover = PyCurrentMover(current=current_mover)
model.movers += c_mover
tideflat = Matroos_Mudflats(current, grid_topology=topology)
land_map = gs.MapFromBNA(mapfile)
model.map = TideflatMap(land_map, tideflat)
## add diffusion
model.movers += RandomMover(diffusion_coef=diffusion_coef)
## loop through start locations
timer3 = datetime.now()
#Todo: can it deal with the test.location.txt file??
start_position = [float(i) for i in StartSite.split(',')]
OutDir = os.path.join(RootDir, TrajectoriesPath, SeasonName,
'pos_%03i' % (RunSite + 1))
make_dir(OutDir)
print " ", RunSite, time_idx
print " Running: start time:", start_time,
print "at start location:", start_position
## set the spill to the location
spill = surface_point_line_spill(
num_elements=NumLEs,
start_position=(start_position[0], start_position[1], 0.0),
release_time=start_time,
end_release_time=start_time + release_duration,
windage_range=windage_range,
windage_persist=windage_persist)
# print "adding netcdf output"
netcdf_output_file = os.path.join(
OutDir,
'pos_%03i-t%03i_%08i.nc' %
(RunSite + 1, time_idx, int(start_time.strftime('%y%m%d%H'))),
)
model.outputters.clear()
model.outputters += NetCDFOutput(
netcdf_output_file,
output_timestep=timedelta(hours=OutputTimestep))
model.spills.clear()
model.spills += spill
model.full_run(rewind=True)
timer4 = datetime.now()
diff = round((timer4 - timer3).total_seconds() / 60, 2)
timingRecord.write("\t\t" + str(RunSite) + " took " + str(diff) +
" minutes to complete")
diff = round((timer4 - timer1).total_seconds() / 3600, 2)
count = len(RunStarts)
timingRecord.write("\t" + str(SeasonName) + " took " + str(diff) +
" hours to finish " + str(count) + " Gnome runs")
#OutDir.close
timingRecord.close
def test_all_movers(start_time, release_delay, duration):
'''
Tests that all the movers at least can be run
Add new ones as they come along!
'''
model = Model()
model.time_step = timedelta(hours=1)
model.duration = timedelta(seconds=model.time_step * duration)
model.start_time = start_time
start_loc = (1., 2., 0.) # random non-zero starting points
# a spill - release after 5 timesteps
release_time = (start_time +
timedelta(seconds=model.time_step * release_delay))
model.spills += point_line_release_spill(num_elements=10,
start_position=start_loc,
release_time=release_time)
# the land-water map
model.map = gnome.map.GnomeMap() # the simplest of maps
# simple mover
model.movers += SimpleMover(velocity=(1., -1., 0.))
assert len(model.movers) == 1
# random mover
model.movers += RandomMover(diffusion_coef=100000)
assert len(model.movers) == 2
# wind mover
series = np.array((start_time, (10, 45)), dtype=datetime_value_2d).reshape(
(1, ))
model.movers += WindMover(Wind(timeseries=series,
units='meter per second'))
assert len(model.movers) == 3
# CATS mover
model.movers += CatsMover(testdata['CatsMover']['curr'])
assert len(model.movers) == 4
# run the model all the way...
num_steps_output = 0
for step in model:
num_steps_output += 1
print 'running step:', step
# test release happens correctly for all cases
if release_delay < duration:
# at least one get_move has been called after release
assert np.all(model.spills.LE('positions')[:, :2] != start_loc[:2])
elif release_delay == duration:
# particles are released after last step so no motion,
# only initial _state
assert np.all(model.spills.LE('positions') == start_loc)
else:
# release_delay > duration so nothing released though model ran
assert len(model.spills.LE('positions')) == 0
# there is the zeroth step, too.
calculated_steps = (model.duration.total_seconds() / model.time_step) + 1
assert num_steps_output == calculated_steps
def test_linearity_of_wind_movers(wind_persist):
'''
WindMover is defined as a linear operation - defining a model
with a single WindMover with 15 knot wind is equivalent to defining
a model with three WindMovers each with 5 knot wind. Or any number of
WindMover's such that the sum of their magnitude is 15knots and the
direction of wind is the same for both cases.
Below is an example which defines two models and runs them.
In model2, there are multiple winds defined so the windage parameter
is reset 3 times for one timestep.
Since windage range and persistence do not change, this only has the effect
of doing the same computation 3 times. However, the results are the same.
The mean and variance of the positions for both models are close.
As windage_persist is decreased, the values become closer.
Setting windage_persist=0 gives the large difference between them.
'''
units = 'meter per second'
start_time = datetime(2012, 1, 1, 0, 0)
series1 = np.array((start_time, (15, 45)),
dtype=datetime_value_2d).reshape((1, ))
series2 = np.array((start_time, (6, 45)),
dtype=datetime_value_2d).reshape((1, ))
series3 = np.array((start_time, (3, 45)),
dtype=datetime_value_2d).reshape((1, ))
num_LEs = 1000
element_type = floating(windage_persist=wind_persist)
model1 = Model(name='model1')
model1.duration = timedelta(hours=1)
model1.time_step = timedelta(hours=1)
model1.start_time = start_time
model1.spills += point_line_release_spill(num_elements=num_LEs,
start_position=(1., 2., 0.),
release_time=start_time,
element_type=element_type)
model1.movers += WindMover(Wind(timeseries=series1, units=units),
make_default_refs=False)
model2 = Model(name='model2')
model2.duration = timedelta(hours=10)
model2.time_step = timedelta(hours=1)
model2.start_time = start_time
model2.spills += point_line_release_spill(num_elements=num_LEs,
start_position=(1., 2., 0.),
release_time=start_time,
element_type=element_type)
# todo: CHECK RANDOM SEED
# model2.movers += WindMover(Wind(timeseries=series1, units=units))
model2.movers += WindMover(Wind(timeseries=series2, units=units))
model2.movers += WindMover(Wind(timeseries=series2, units=units))
model2.movers += WindMover(Wind(timeseries=series3, units=units))
model2.set_make_default_refs(False)
while True:
try:
model1.next()
except StopIteration as ex:
# print message
print ex.message
break
while True:
try:
model2.next()
except StopIteration as ex:
# print message
print ex.message
break
# mean and variance at the end should be fairly close
# look at the mean of the position vector. Assume m1 is truth
# and m2 is approximation - look at the absolute error between
# mean position of m2 in the 2 norm.
# rel_mean_error =(np.linalg.norm(np.mean(model2.spills.LE('positions'), 0)
# - np.mean(model1.spills.LE('positions'), 0)))
# assert rel_mean_error <= 0.5
# Similarly look at absolute error in variance of position of m2
# in the 2 norm.
rel_var_error = np.linalg.norm(np.var(model2.spills.LE('positions'), 0) -
np.var(model1.spills.LE('positions'), 0))
assert rel_var_error <= 0.0015
def test_all_movers(start_time, release_delay, duration):
'''
Tests that all the movers at least can be run
Add new ones as they come along!
'''
model = Model()
model.time_step = timedelta(hours=1)
model.duration = timedelta(seconds=model.time_step * duration)
model.start_time = start_time
start_loc = (1., 2., 0.) # random non-zero starting points
# a spill - release after 5 timesteps
release_time = (start_time +
timedelta(seconds=model.time_step * release_delay))
model.spills += point_line_release_spill(num_elements=10,
start_position=start_loc,
release_time=release_time)
# the land-water map
model.map = gnome.map.GnomeMap() # the simplest of maps
# simple mover
model.movers += SimpleMover(velocity=(1., -1., 0.))
assert len(model.movers) == 1
# random mover
model.movers += RandomMover(diffusion_coef=100000)
assert len(model.movers) == 2
# wind mover
series = np.array((start_time, (10, 45)),
dtype=datetime_value_2d).reshape((1, ))
model.movers += WindMover(Wind(timeseries=series,
units='meter per second'))
assert len(model.movers) == 3
# CATS mover
model.movers += CatsMover(testdata['CatsMover']['curr'])
assert len(model.movers) == 4
# run the model all the way...
num_steps_output = 0
for step in model:
num_steps_output += 1
print 'running step:', step
# test release happens correctly for all cases
if release_delay < duration:
# at least one get_move has been called after release
assert np.all(model.spills.LE('positions')[:, :2] != start_loc[:2])
elif release_delay == duration:
# particles are released after last step so no motion,
# only initial _state
assert np.all(model.spills.LE('positions') == start_loc)
else:
# release_delay > duration so nothing released though model ran
assert len(model.spills.LE('positions')) == 0
# there is the zeroth step, too.
calculated_steps = (model.duration.total_seconds() / model.time_step) + 1
assert num_steps_output == calculated_steps
def test_linearity_of_wind_movers(wind_persist):
'''
WindMover is defined as a linear operation - defining a model
with a single WindMover with 15 knot wind is equivalent to defining
a model with three WindMovers each with 5 knot wind. Or any number of
WindMover's such that the sum of their magnitude is 15knots and the
direction of wind is the same for both cases.
Below is an example which defines two models and runs them.
In model2, there are multiple winds defined so the windage parameter
is reset 3 times for one timestep.
Since windage range and persistence do not change, this only has the effect
of doing the same computation 3 times. However, the results are the same.
The mean and variance of the positions for both models are close.
As windage_persist is decreased, the values become closer.
Setting windage_persist=0 gives the large difference between them.
'''
units = 'meter per second'
start_time = datetime(2012, 1, 1, 0, 0)
series1 = np.array((start_time, (15, 45)),
dtype=datetime_value_2d).reshape((1, ))
series2 = np.array((start_time, (6, 45)), dtype=datetime_value_2d).reshape(
(1, ))
series3 = np.array((start_time, (3, 45)), dtype=datetime_value_2d).reshape(
(1, ))
num_LEs = 1000
element_type = floating(windage_persist=wind_persist)
model1 = Model(name='model1')
model1.duration = timedelta(hours=1)
model1.time_step = timedelta(hours=1)
model1.start_time = start_time
model1.spills += point_line_release_spill(num_elements=num_LEs,
start_position=(1., 2., 0.),
release_time=start_time,
element_type=element_type)
model1.movers += WindMover(Wind(timeseries=series1, units=units),
make_default_refs=False)
model2 = Model(name='model2')
model2.duration = timedelta(hours=10)
model2.time_step = timedelta(hours=1)
model2.start_time = start_time
model2.spills += point_line_release_spill(num_elements=num_LEs,
start_position=(1., 2., 0.),
release_time=start_time,
element_type=element_type)
# todo: CHECK RANDOM SEED
# model2.movers += WindMover(Wind(timeseries=series1, units=units))
model2.movers += WindMover(Wind(timeseries=series2, units=units))
model2.movers += WindMover(Wind(timeseries=series2, units=units))
model2.movers += WindMover(Wind(timeseries=series3, units=units))
model2.set_make_default_refs(False)
while True:
try:
model1.next()
except StopIteration as ex:
# print message
print ex.message
break
while True:
try:
model2.next()
except StopIteration as ex:
# print message
print ex.message
break
# mean and variance at the end should be fairly close
# look at the mean of the position vector. Assume m1 is truth
# and m2 is approximation - look at the absolute error between
# mean position of m2 in the 2 norm.
# rel_mean_error =(np.linalg.norm(np.mean(model2.spills.LE('positions'), 0)
# - np.mean(model1.spills.LE('positions'), 0)))
# assert rel_mean_error <= 0.5
# Similarly look at absolute error in variance of position of m2
# in the 2 norm.
rel_var_error = np.linalg.norm(
np.var(model2.spills.LE('positions'), 0) -
np.var(model1.spills.LE('positions'), 0))
assert rel_var_error <= 0.0015
def test_simple_run_with_image_output_uncertainty():
"""
pretty much all this tests is that the model will run and output images
"""
# create a place for test images (cleaning out any old ones)
images_dir = os.path.join(basedir, 'Test_images2')
if os.path.isdir(images_dir):
shutil.rmtree(images_dir)
os.mkdir(images_dir)
start_time = datetime(2012, 9, 15, 12, 0)
# the land-water map
gmap = gnome.map.MapFromBNA(testmap, refloat_halflife=6) # hours
renderer = gnome.renderer.Renderer(testmap, images_dir, size=(400,
300))
model = Model(
time_step=timedelta(minutes=15),
start_time=start_time,
duration=timedelta(hours=1),
map=gmap,
uncertain=True,
cache_enabled=False,
)
model.outputters += renderer
a_mover = SimpleMover(velocity=(1., -1., 0.))
model.movers += a_mover
N = 10 # a line of ten points
start_points = np.zeros((N, 3), dtype=np.float64)
start_points[:, 0] = np.linspace(-127.1, -126.5, N)
start_points[:, 1] = np.linspace(47.93, 48.1, N)
# print start_points
spill = SpatialRelease(start_positions=start_points,
release_time=start_time)
model.spills += spill
# model.add_spill(spill)
model.start_time = spill.release_time
# image_info = model.next_image()
model.uncertain = True
num_steps_output = 0
while True:
try:
image_info = model.step()
num_steps_output += 1
print image_info
except StopIteration:
print 'Done with the model run'
break
# there is the zeroth step, too.
assert num_steps_output == model.duration.total_seconds() \
/ model.time_step + 1
