def test_num_per_timestep_release_elements(self): 'release elements in the context of a spill container' # todo: need a test for a line release where rate is given - to check # positions are being initialized correctly end_time = self.rel_time + timedelta(hours=1) release = ContinuousRelease(self.rel_time, self.pos, num_per_timestep=100, initial_elements=1000, end_release_time=end_time) s = Spill(release) sc = SpillContainer() sc.spills += s sc.prepare_for_model_run() for ix in range(5): time = self.rel_time + timedelta(seconds=900 * ix) num_les = sc.release_elements(900, time) if time <= s.get('end_release_time'): if ix == 0: assert num_les == 1100 else: assert num_les == 100 assert sc.num_released == 100 + ix * 100 + 1000 else: assert num_les == 0
def test_spills_with_and_notwith_substance(self): ''' datastructure only adds substance/spills if substance is not None deleting spill resets datastructure. - the spills in _substances_spills 'is' the same as the spills in sc.spills - same object ''' sc = SpillContainer() sc.spills += [ Spill(Release(datetime.now(), 10), element_type=floating(substance=None), name='spill0'), Spill(Release(datetime.now(), 10), element_type=floating(substance=test_oil), name='spill1') ] assert len(sc.get_substances()) == 2 sc.prepare_for_model_run() all_spills = list(chain.from_iterable(sc._substances_spills.spills)) assert len(all_spills) == len(sc.spills) for spill in all_spills: assert sc.spills[spill.id] is spill del sc.spills[-1] assert len(sc.get_substances()) == 1 assert len(sc.iterspillsbysubstance()) == 1
def test_initailize_InitMassFromVolume(): data_arrays = mock_append_data_arrays(mass_array, num_elems) fcn = InitMassFromVolume() spill = Spill() spill.volume = num_elems / (spill.oil_props.get_density('kg/m^3') * 1000) fcn.initialize(num_elems, spill, data_arrays) assert_dataarray_shape_size(mass_array, data_arrays, num_elems) assert np.all(1. == data_arrays['mass'])
def test_serialization_deserialization(self): """ tests serializatin/deserialization of the Spill object """ spill = point_line_release_spill(num_elements=self.num_elements, start_position=self.start_position, release_time=self.release_time) serial = spill.serialize('create') new_dict = Spill.deserialize(serial) # classmethod new_spill = Spill.new_from_dict(new_dict) # classmethod assert spill == new_spill
def test_init_exceptions(): with raises(TypeError): Spill(Release(datetime.now()), amount=10) with raises(ValueError): Spill(Release(release_time=datetime.now()), element_type=floating(windage_range=(-1, 0))) with raises(ValueError): Spill(Release(release_time=datetime.now()), element_type=floating(windage_persist=0))
def test_initailize_InitMassFromVolume(): data_arrays = mock_append_data_arrays(mass_array, num_elems) substance = OilProps('oil_conservative') spill = Spill(Release(10)) spill.volume = num_elems / (substance.get_density('kg/m^3') * 1000) fcn = InitMassFromVolume() fcn.initialize(num_elems, spill, data_arrays, substance) assert_dataarray_shape_size(mass_array, data_arrays, num_elems) assert np.all(1. == data_arrays['mass'])
def test_initailize_InitMassFromTotalMass(): data_arrays = mock_append_data_arrays(mass_array, num_elems) substance = OilProps('oil_conservative') spill = Spill(Release()) spill.release.num_elements = 10 spill.mass = num_elems fcn = InitMassFromTotalMass() fcn.initialize(num_elems, spill, data_arrays, substance) assert_dataarray_shape_size(mass_array, data_arrays, num_elems) assert np.all(1. == data_arrays['mass'])
def test_initailize_InitMassFromTotalMass(): data_arrays = mock_append_data_arrays(mass_array, num_elems) substance = OilProps("oil_conservative") spill = Spill(Release(datetime.now())) spill.release.num_elements = 10 spill.set_mass(num_elems, units="g") fcn = InitMassFromTotalMass() fcn.initialize(num_elems, spill, data_arrays, substance) assert_dataarray_shape_size(mass_array, data_arrays, num_elems) assert np.all(1.0 == data_arrays["mass"])
def test_total_mass(): ''' test total_mass attribute ''' sc = SpillContainer() sc.spills += [ Spill(Release(datetime.now(), 10), amount=100, units='kg'), Spill(Release(datetime.now(), 1000), amount=1234, units='kg'), Spill(Release(datetime.now(), 100)) ] assert sc.total_mass == 100 + 1234 sc.spills.clear() sc.spills += [Spill(Release(datetime.now(), 10))] assert sc.total_mass is None
def model(sample_model, output_dir): model = sample_model['model'] rel_start_pos = sample_model['release_start_pos'] rel_end_pos = sample_model['release_end_pos'] model.cache_enabled = True model.uncertain = True N = 10 # a line of ten points line_pos = np.zeros((N, 3), dtype=np.float64) line_pos[:, 0] = np.linspace(rel_start_pos[0], rel_end_pos[0], N) line_pos[:, 1] = np.linspace(rel_start_pos[1], rel_end_pos[1], N) # print start_points model.environment += td model.spills += point_line_release_spill(1, start_position=rel_start_pos, release_time=model.start_time, end_position=rel_end_pos) release = SpatialRelease(start_position=line_pos, release_time=model.start_time) model.spills += Spill(release) model.movers += c_cats model.outputters += CurrentJsonOutput([c_cats]) model.rewind() return model
def model(sample_model, output_dir): model = sample_model['model'] rel_start_pos = sample_model['release_start_pos'] rel_end_pos = sample_model['release_end_pos'] model.start_time = datetime(2015, 5, 14, 0) model.cache_enabled = True model.uncertain = True N = 10 # a line of ten points line_pos = np.zeros((N, 3), dtype=np.float64) line_pos[:, 0] = np.linspace(rel_start_pos[0], rel_end_pos[0], N) line_pos[:, 1] = np.linspace(rel_start_pos[1], rel_end_pos[1], N) start_pos = (-164.01696, 72.921024, 0) model.spills += point_line_release_spill(1, start_position=start_pos, release_time=model.start_time, end_position=start_pos) release = SpatialRelease(start_position=line_pos, release_time=model.start_time) model.spills += Spill(release) model.movers += c_ice_mover model.outputters += IceGeoJsonOutput([c_ice_mover]) model.rewind() return model
def test_validate_model_spills_time_mismatch_warning(self): ''' test warning messages output for no spills and model start time mismatch with release time ''' model = Model(start_time=self.start_time) (msgs, isvalid) = model.check_inputs() print model.environment print msgs, isvalid assert len(msgs) == 1 and isvalid assert ('{0} contains no spills'.format(model.name) in msgs[0]) model.spills += Spill(Release(self.start_time + timedelta(hours=1), 1)) (msgs, isvalid) = model.check_inputs() assert len(msgs) == 1 and isvalid assert ('{} has release time after model start time'.format( model.spills[0].name) in msgs[0]) model.spills[0].release_time = self.start_time - timedelta(hours=1) (msgs, isvalid) = model.check_inputs() assert len(msgs) == 1 and not isvalid assert ('{} has release time before model start time'.format( model.spills[0].name) in msgs[0])
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_spills_same_substance_init(self): sc = SpillContainer() et = floating(substance=test_oil) sp_add = [ point_line_release_spill(3, (1, 1, 1), datetime.now(), element_type=et), Spill(Release(datetime.now(), 10), amount=100, units='kg', element_type=floating(substance=test_oil)), Spill(Release(datetime.now(), 10), element_type=floating(substance=et.substance)) ] sc.spills += sp_add assert len(sc.get_substances()) == 1 sc.prepare_for_model_run() assert all([sp_add == spills for spills in sc.iterspillsbysubstance()])
def test_serialization_deserialization(self, json_): """ tests serializatin/deserialization of the Spill object """ spill = point_line_release_spill(num_elements=self.num_elements, start_position=self.start_position, release_time=self.release_time) dict_ = Spill.deserialize(spill.serialize(json_)) if json_ == 'save': new_spill = Spill.new_from_dict(dict_) assert spill == new_spill else: # for webapi, make new objects from nested objects before creating # new element_type dict_['element_type'] = spill.element_type dict_['release'] = spill.release new_spill = Spill.new_from_dict(dict_) assert True
def test_SpillContainer_add_array_types(): ''' Test an array_type is dynamically added/subtracted from SpillContainer if it is contained in Initailizer's array_types property. For example: Add 'rise_vel' initializer, InitRiseVelFromDropletSizeFromDist()) is added to Spill's element_type object. Now, the array_types for this initailizer are 'rise_vel' and 'droplet_diameter'. Only if a RiseVelocityMover is added to the model in which case the Model provides 'rise_vel' as an array_type to the SpillContainer to append it to its own list, then the SpillContainer will also add the 'droplet_diameter' array_type that is additionally set by the Initializer but is not explicitly required by the Mover. ''' sc = SpillContainer() s = Spill(Release(datetime(2014, 1, 1, 12, 0), 0)) s.set_initializer( InitRiseVelFromDropletSizeFromDist(distribution=UniformDistribution())) sc.spills += s assert 'rise_vel' not in sc.array_types assert 'droplet_diameter' not in sc.array_types # Now say you added RiseVelocityMover and the Model collects ArrayTypes # from all movers and passes it into SpillContainer's prepare_for_model_run # sc.prepare_for_model_run(array_types={'rise_vel'}) assert 'rise_vel' in sc.array_types assert 'droplet_diameter' in sc.array_types # calling prepare_for_model_run without different array_types keeps the # previously added 'rise_vel' array_types - always rewind if you want to # clear out the state and reset array_types to original data sc.prepare_for_model_run() assert 'rise_vel' in sc.array_types assert 'droplet_diameter' in sc.array_types # Now let's rewind array_types and these extra properties should disappear # they are only added after the prepare_for_model_run step sc.rewind() sc.prepare_for_model_run() assert 'rise_vel' not in sc.array_types assert 'droplet_diameter' not in sc.array_types
def test_spills_different_substance_init(self): sc = SpillContainer() splls0 = [ point_line_release_spill( 3, (1, 1, 1), datetime.now(), element_type=floating(substance=test_oil)), Spill(Release(datetime.now(), 10), element_type=floating(substance=test_oil)), ] sc.spills += splls0 splls1 = [ Spill(Release(datetime.now(), 10), element_type=floating(substance='oil_crude')) ] sc.spills += splls1 assert (len(sc.get_substances()) == 2 and len(sc.iterspillsbysubstance()) == 2)
def test_set_newparticle_positions(self): 'define two spatial releases and check positions are set correctly' sp2 = Spill(SpatialRelease(self.sp.release.release_time, ((0, 0, 0), (0, 0, 0)))) (data_arrays, num) = release_elements(self.sp, self.sp.release.release_time, 600) assert (self.sp.get('num_released') == self.sp.release.num_elements and self.sp.release.num_elements == num) (data_arrays, num2) = release_elements(sp2, sp2.release.release_time, 600, data_arrays) assert (sp2.get('num_released') == sp2.release.num_elements and len(data_arrays['positions']) == num2 + num) assert (np.all(data_arrays['positions'][:num, :] == self.sp.get('start_position'))) assert (np.all(data_arrays['positions'][num:, :] == sp2.get('start_position')))
def test_SpillContainer_add_array_types(): ''' Test an array_type is dynamically added/subtracted from SpillContainer if it is contained in Initailizer's array_types property. For example: Add 'rise_vel' initializer, InitRiseVelFromDropletSizeFromDist()) is added to Spill's element_type object. Now, the array_types for this initailizer are 'rise_vel' and 'droplet_diameter'. Only if a RiseVelocityMover is added to the model in which case the Model provides 'rise_vel' as an array_type to the SpillContainer to append it to its own list, then the SpillContainer will also add the 'droplet_diameter' array_type that is additionally set by the Initializer but is not explicitly required by the Mover. ''' sc = SpillContainer() s = Spill(Release(datetime(2014, 1, 1, 12, 0), 0)) s.set_initializer(InitRiseVelFromDropletSizeFromDist(distribution = UniformDistribution())) sc.spills += s assert 'rise_vel' not in sc.array_types assert 'droplet_diameter' not in sc.array_types # Now say you added RiseVelocityMover and the Model collects ArrayTypes # from all movers and passes it into SpillContainer's prepare_for_model_run # sc.prepare_for_model_run(array_types={'rise_vel'}) assert 'rise_vel' in sc.array_types assert 'droplet_diameter' in sc.array_types # calling prepare_for_model_run without different array_types keeps the # previously added 'rise_vel' array_types - always rewind if you want to # clear out the state and reset array_types to original data sc.prepare_for_model_run() assert 'rise_vel' in sc.array_types assert 'droplet_diameter' in sc.array_types # Now let's rewind array_types and these extra properties should disappear # they are only added after the prepare_for_model_run step sc.rewind() sc.prepare_for_model_run() assert 'rise_vel' not in sc.array_types assert 'droplet_diameter' not in sc.array_types
def test_serialization_deserialization(self, json_, amount, units): """ tests serializatin/deserialization of the Spill object """ spill = point_line_release_spill(num_elements=self.num_elements, start_position=self.start_position, release_time=self.release_time, amount=amount, units=units) new_spill = Spill.deserialize(spill.serialize()) assert new_spill == spill
def test_amount_mass_vol(amount, units): ''' ensure mass is being returned correctly when 'amount' is initialized wtih 'mass' or 'volume' ''' spill = Spill(Release(datetime.now()), amount=amount, units=units, substance=test_oil) assert spill.amount == amount assert spill.units == units if units in Spill.valid_vol_units: exp_mass = (spill.get('substance').get_density() * uc.convert('Volume', units, 'm^3', spill.amount)) else: exp_mass = uc.convert('Mass', units, 'kg', spill.amount) assert spill.get_mass() == exp_mass exp_mass_g = exp_mass * 1000 assert spill.get_mass('g') == exp_mass_g
def test_set_newparticle_positions(self): 'define two spatial releases and check positions are set correctly' sp2 = Spill( SpatialRelease(self.sp.release.release_time, ((0, 0, 0), (0, 0, 0)))) (data_arrays, num) = release_elements(self.sp, self.sp.release.release_time, 600) assert (self.sp.get('num_released') == self.sp.release.num_elements and self.sp.release.num_elements == num) (data_arrays, num2) = release_elements(sp2, sp2.release.release_time, 600, data_arrays) assert (sp2.get('num_released') == sp2.release.num_elements and len(data_arrays['positions']) == num2 + num) assert (np.all( data_arrays['positions'][:num, :] == self.sp.get('start_position')) ) assert (np.all( data_arrays['positions'][num:, :] == sp2.get('start_position')))
def test_serialization_deserialization(self, json_, amount, units): """ tests serializatin/deserialization of the Spill object """ spill = point_line_release_spill(num_elements=self.num_elements, start_position=self.start_position, release_time=self.release_time, amount=amount, units=units) dict_ = Spill.deserialize(spill.serialize(json_)) if json_ == 'save': new_spill = Spill.new_from_dict(dict_) assert spill == new_spill else: # for webapi, make new objects from nested objects before creating # new element_type dict_['element_type'] = spill.element_type dict_['release'] = spill.release new_spill = Spill.new_from_dict(dict_) assert True
def test_num_per_timestep_release_elements(self): 'release elements in the context of a spill container' # todo: need a test for a line release where rate is given - to check # positions are being initialized correctly end_time = self.rel_time + timedelta(hours=1) release = PointLineRelease(self.rel_time, self.pos, num_per_timestep=100, end_release_time=end_time) s = Spill(release) sc = SpillContainer() sc.spills += s sc.prepare_for_model_run() for ix in range(5): time = self.rel_time + timedelta(seconds=900 * ix) num_les = sc.release_elements(900, time) if time <= s.get('end_release_time'): assert num_les == 100 assert sc.num_released == 100 + ix * 100 else: assert num_les == 0
def test_full_run(self): 'just check that all data arrays work correctly' s = Spill(InitElemsFromFile(testdata['nc']['nc_output'])) model = Model(start_time=s.get('release_time'), time_step=self.time_step.total_seconds(), duration=timedelta(days=2)) model.spills += s model.movers += RandomMover() # setup model run for step in model: if step['step_num'] == 0: continue for sc in model.spills.items(): for key in sc.data_arrays.keys(): # following keys will not change with run if key in ('status_codes', 'mass', 'id', 'spill_num', 'last_water_positions'): # all water map assert np.all(sc[key] == s.release._init_data[key]) else: assert np.any(sc[key] != s.release._init_data[key])
def make_model_incomplete_waves(self): ''' create a model with waves objects with no referenced wind, water. Include Spill so we don't get warnings for it ''' model = Model(start_time=self.start_time) model.spills += Spill(Release(self.start_time, 1)) waves = Waves() model.environment += waves return (model, waves)
def test_copy(): """ TODO: how should this work """ sp1 = Spill(Release(release_time=datetime.now().replace(microsecond=0))) sp2 = copy.copy(sp1) assert sp1 is not sp2 assert sp1.id != sp2.id # try deleting the copy, and see if any errors result del sp1 del sp2
def test_no_substance(self): ''' no substance means run trajectory without an OilProps object/without weathering is one reason to do this ''' sc = SpillContainer() sc.spills += [ Spill(Release(datetime.now(), 10), element_type=floating(substance=None), name='spill0'), Spill(Release(datetime.now(), 10), element_type=floating(substance=None), name='spill1') ] assert len(sc.itersubstancedata('mass')) == 0 assert len(sc.get_substances()) == 1 # iterspillsbysubstance() iterates through all the spills associated # with each substance including the spills where substance is None assert len(sc.iterspillsbysubstance()) == 1 assert len(sc.iterspillsbysubstance()) == 1
def test_deepcopy(): """ tests that a deepcopy results in a copy so objects are not the same todo: how should this work? """ sp1 = Spill(Release(release_time=datetime.now().replace(microsecond=0))) sp2 = copy.deepcopy(sp1) assert sp1 is not sp2 assert sp1.id != sp2.id # try deleting the copy, and see if any errors result del sp2 del sp1
def test_var_attr_spill_num(output_filename): ''' call prepare_for_model_run and ensure the spill_num attributes are written correctly. Just a simple test that creates two models and adds a spill to each. It then runs both models and checks that the correct spill_name exists in 'spills_map' attribute for NetCDF output variable 'spill_num' ''' def _make_run_model(spill, nc_name): 'internal function' release_time = spill.release.release_time m = Model(start_time=release_time) m.outputters += NetCDFOutput(nc_name) m.spills += spill _run_model(m) return m def _del_nc_file(nc_name): try: os.remove(nc_name) except: pass here = os.path.dirname(__file__) spills = [] model = [] nc_name = [] for ix in (0, 1): spills.append( Spill(Release(datetime.now()), name='m{0}_spill'.format(ix))) nc_name.append(os.path.join(here, 'temp_m{0}.nc'.format(ix))) _del_nc_file(nc_name[ix]) _make_run_model(spills[ix], nc_name[ix]) # open and check the correct spill_name exists in each netcdf file for ix, f_ in enumerate(nc_name): with nc.Dataset(f_) as data: assert (spills[ix].name in data.variables['spill_num'].spills_map) if ix == 0: assert (spills[1].name not in data.variables['spill_num'].spills_map) if ix == 1: assert (spills[0].name not in data.variables['spill_num'].spills_map) _del_nc_file(nc_name[ix])
def test_amount_mass_vol(amount, units): ''' ensure mass is being returned correctly when 'amount' is initialized wtih 'mass' or 'volume' ''' water = Water() spill = Spill(Release(datetime.now()), amount=amount, units=units, substance=test_oil, water=water) assert spill.amount == amount assert spill.units == units if units in Spill.valid_vol_units: # use 15C (288.15K) for mass<=>volume conversion exp_mass = (spill.substance.density_at_temp(288.15) * uc.convert('Volume', units, 'm^3', spill.amount)) else: exp_mass = uc.convert('Mass', units, 'kg', spill.amount) assert spill.get_mass() == exp_mass exp_mass_g = exp_mass * 1000 assert spill.get_mass('g') == exp_mass_g
def test_release_elements(self, at): 'release elements in the context of a spill container' s = Spill(InitElemsFromFile(testdata['nc']['nc_output'])) sc = SpillContainer() sc.spills += s sc.prepare_for_model_run(array_types=at) num_les = sc.release_elements(self.time_step, self.nc_start_time) assert sc.num_released == s.release.num_elements assert num_les == s.release.num_elements for array, val in s.release._init_data.iteritems(): if array in sc: assert np.all(val == sc[array]) assert val is not sc[array] else: assert array not in at
def sample_vertical_plume_spill(): ''' creates an example VerticalPlumeSource object ''' from gnome.spill import VerticalPlumeRelease, Spill from gnome.utilities.plume import get_plume_data release_time = datetime.now() vps = VerticalPlumeRelease(num_elements=200, start_position=(28, -78, 0.), release_time=release_time, end_release_time=release_time + timedelta(hours=24), plume_data=get_plume_data()) vps.plume_gen.time_step_delta = timedelta(hours=1).total_seconds() return Spill(vps)
def test_initialize_InitRiseVelFromDropletDist_weibull(): 'Test initialize data_arrays with Weibull dist' num_elems = 10 data_arrays = mock_append_data_arrays(rise_vel_diameter_array, num_elems) substance = get_oil_props(oil) spill = Spill(Release(datetime.now()), water=Water()) # (.001*.2) / (.693 ** (1 / 1.8)) - smaller droplet test case, in mm # so multiply by .001 dist = WeibullDistribution(alpha=1.8, lambda_=.000248) fcn = InitRiseVelFromDropletSizeFromDist(dist) fcn.initialize(num_elems, spill, data_arrays, substance) assert_dataarray_shape_size(rise_vel_array, data_arrays, num_elems) assert np.all(0 != data_arrays['rise_vel']) assert np.all(0 != data_arrays['droplet_diameter'])
def test_init(element_type, amount): ''' Test various initializations ''' spill = Spill(Release(release_time=datetime.now()), element_type=element_type, amount=amount, units='kg') if element_type is None: assert np.all(spill.windage_range == (0.01, 0.04)) assert spill.windage_persist == 900 # no need to test this in spill -- it shouldn't know about initializers # assert len(spill.initializers) == 1 # add windages # else: # assert len(spill.initializers) == 0 assert spill.release_duration == 0
def test_initialize_InitRiseVelFromDropletDist_weibull_with_min_max(): 'Test initialize data_arrays with Weibull dist' num_elems = 1000 data_arrays = mock_append_data_arrays(rise_vel_diameter_array, num_elems) substance = get_oil_props(oil) spill = Spill(Release(datetime.now()), water=Water()) # (.001*3.8) / (.693 ** (1 / 1.8)) - larger droplet test case, in mm # so multiply by .001 dist = WeibullDistribution(min_=0.002, max_=0.004, alpha=1.8, lambda_=.00456) fcn = InitRiseVelFromDropletSizeFromDist(dist) fcn.initialize(num_elems, spill, data_arrays, substance) # test for the larger droplet case above assert np.all(data_arrays['droplet_diameter'] >= .002) # test for the larger droplet case above assert np.all(data_arrays['droplet_diameter'] <= .004)
def test_init(element_type, amount): ''' Test various initializtions ''' spill = Spill(Release(release_time=datetime.now()), element_type=element_type, amount=amount, units='kg') if element_type is None: assert np.all(spill.get('windage_range') == (0.01, 0.04)) assert (spill.get('windage_persist') == 900) assert len(spill.get('initializers')) == 1 # add windages else: assert len(spill.get('initializers')) == 0 assert spill.name == 'Spill' assert spill.get('release_duration') == 0
def test_set_newparticle_positions(self): 'define two spatial releases and check positions are set correctly' sp2 = Spill( SpatialRelease(self.sp.release.release_time, ((0, 0, 0), (0, 0, 0)))) (data_arrays, num) = release_elements(self.sp, self.sp.release.release_time, 600) # fixme -- should we be checking for the release inside the Spill? assert (self.sp.num_released == self.sp.release.num_elements and self.sp.release.num_elements == num) (data_arrays, num2) = release_elements(sp2, sp2.release.release_time, 600, data_arrays) assert (sp2.num_released == sp2.release.num_elements and len(data_arrays['positions']) == num2 + num) assert (np.all( data_arrays['positions'][:num, :] == self.sp.start_position)) assert (np.all( data_arrays['positions'][num:, :] == sp2.start_position))
def make_model(images_dir): print 'initializing the model' timestep = timedelta(minutes=15) # this is already default start_time = datetime(2012, 9, 15, 12, 0) model = Model(timestep, start_time) # timeseries for wind data. The value is interpolated if time is between # the given datapoints series = np.zeros((4, ), dtype=datetime_value_2d) series[:] = [(start_time, (5, 180)), (start_time + timedelta(hours=6), (10, 180)), (start_time + timedelta(hours=12), (12, 180)), (start_time + timedelta(hours=18), (8, 180))] wind = Wind(timeseries=series, units='m/s') model.environment += wind # include a wind mover and random diffusion print 'adding movers' model.movers += [WindMover(wind), RandomMover()] # add particles print 'adding particles' release = release_from_splot_data(start_time, 'GL.2013267._LE_WHOLELAKE.txt') model.spills += Spill(release) # output data as png images and in netcdf format print 'adding outputters' netcdf_file = os.path.join(base_dir, 'script_example.nc') # ignore renderer for now model.outputters += [ Renderer(images_dir=images_dir, size=(800, 800), projection_class=GeoProjection), NetCDFOutput(netcdf_file) ] print 'model complete' return model
def test_init(element_type, amount): ''' Test various initializtions ''' spill = Spill(Release(release_time=datetime.now()), element_type=element_type, amount=amount, units='kg' ) if element_type is None: assert np.all(spill.get('windage_range') == (0.01, 0.04)) assert (spill.get('windage_persist') == 900) assert len(spill.get('initializers')) == 1 # add windages else: assert len(spill.get('initializers')) == 0 assert spill.name == 'Spill' assert spill.get('release_duration') == 0