def __init__(self, bounds, dry_start, dry_end): """ :param bounds: polygon around the tidal flat :dry_start: initial time of flat being dry :dry_end: end time of flat being dry """ self.bounds = np.array(bounds, dtype=np.float64).reshape((-1, 2)) self.dry_start = asdatetime(dry_start) self.dry_end = asdatetime(dry_end)
def __init__(self, release_time=None, num_elements=0, release_mass=0, **kwargs): self.num_elements = num_elements self.release_time = asdatetime(release_time) self.release_mass = release_mass self.rewind() super(Release, self).__init__(**kwargs) self.array_types.update({ 'positions': gat('positions'), 'mass': gat('mass'), 'init_mass': gat('mass') })
def end_release_time(self, val): ''' Set end_release_time. If end_release_time is None or if end_release_time == release_time, it is an instantaneous release. Also update reference to set_newparticle_positions - if this was previously an instantaneous release but is now timevarying, we need to update this method ''' val = asdatetime(val) if val is not None and self.continuous.release_time > val: raise ValueError('end_release_time must be greater than ' 'release_time') self.continuous.end_release_time = val
def end_release_time(self, val): ''' Set end_release_time. If end_release_time is None or if end_release_time == release_time, it is an instantaneous release. Also update reference to set_newparticle_positions - if this was previously an instantaneous release but is now timevarying, we need to update this method ''' val = asdatetime(val) if val is not None and self.release_time > val: raise ValueError('end_release_time must be greater than ' 'release_time') self._end_release_time = val
def __init__(self, release_time=None, num_elements=0, num_released=0, start_time_invalid=None, **kwargs): super(Release, self).__init__(**kwargs) self._num_elements = num_elements self.release_time = asdatetime(release_time) # number of new particles released at each timestep # set/updated by the derived Release classes at each timestep self.num_released = num_released # flag determines if the first time is valid. If the first call to # self.num_elements_to_release(current_time, time_step) has # current_time > self.release_time, then no particles are ever released # model start time is valid self.start_time_invalid = start_time_invalid
def test_asdatetime_str2(): dt = asdatetime("2010-06-01 12:30") assert isinstance(dt, datetime) assert dt == datetime(2010, 6, 1, 12, 30)
def __init__(self, release_time=None, start_position=None, num_elements=None, num_per_timestep=None, end_release_time=None, end_position=None, release_mass=0, **kwargs): """ Required Arguments: :param release_time: time the LEs are released (datetime object) :type release_time: datetime.datetime :param start_position: initial location the elements are released :type start_position: 3-tuple of floats (long, lat, z) Optional arguments: .. note:: Either num_elements or num_per_timestep must be given. If both are None, then it defaults to num_elements=1000. If both are given a TypeError is raised because user can only specify one or the other, not both. :param num_elements: total number of elements to be released :type num_elements: integer :param num_per_timestep: fixed number of LEs released at each timestep :type num_elements: integer :param end_release_time=None: optional -- for a time varying release, the end release time. If None, then release is instantaneous :type end_release_time: datetime.datetime :param end_position=None: optional. For moving source, the end position If None, then release from a point source :type end_position: 3-tuple of floats (long, lat, z) :param release_mass=0: optional. This is the mass released in kilograms. :type release_mass: integer num_elements and release_time passed to base class __init__ using super See base :class:`Release` documentation """ self._num_elements = self._num_per_timestep = None if num_elements is None and num_per_timestep is None: num_elements = 1000 super(PointLineRelease, self).__init__(release_time=release_time, num_elements=num_elements, release_mass=release_mass, **kwargs) if num_elements is not None and num_per_timestep is not None: msg = ('Either num_elements released or a release rate, defined by' ' num_per_timestep must be given, not both') raise TypeError(msg) self._num_per_timestep = num_per_timestep # initializes internal variables: _end_release_time, _start_position, # _end_position self.end_release_time = asdatetime(end_release_time) self.start_position = start_position self.end_position = end_position
def __init__(self, num_elements=1000, num_per_timestep=None, start_position=(0.0, 0.0, 1000.), release_time=datetime.now(), # just so it gets something... release_rate=0.0, release_duration=timedelta(hours=1), units='bbl/day', substance=None, release=None, water=None, gor=None, d0=0.0, phi_0=-np.pi / 2.0, theta_0=0.0, windage_range=(0.01, 0.04), windage_persist=900, on=True, name=None, **kwargs): self.substance = substance # compute the total release amount # this is all pretty kludgy # but I think we are expecting a Spill to have a total amount # we may be able to relax that later. release_time = asdatetime(release_time) end_release_time = release_time + release_duration try: # if it was provided in mass discharge units: release_rate = uc.convert(units, "kg/s", release_rate) except uc.UnitConversionError: # Trying volume discharge units # must be in volume discharge release_rate = uc.convert(units, "m^3/s", release_rate) # convert to kg/s discharge with density release_rate = release_rate * self.substance.standard_density amount = release_rate * release_duration.total_seconds() self.release_mass = amount super(TamocSpill, self).__init__(num_elements=num_elements, amount=amount, # could be volume or mass units='kg', substance=self.substance, release=None, on=on, **kwargs) # removing the release, so we can duplicate its functionality self.release = None self.release_time = release_time self.end_release_time = end_release_time self.frac_coverage = 1.0 self._num_released = 0 # Initialize internal element counters to None self._num_elements = self._num_per_timestep = None # Ensure either the number of elements or the release rate is given if num_elements is None and num_per_timestep is None: num_elements = 1000 # Error check whether the number of elements is over specified if num_elements is not None and num_per_timestep is not None: msg = ('Either num_elements released or a release rate,' 'defined by num_per_timestep must be given, not both') raise TypeError(msg) self.start_position = start_position self.release_time=asdatetime(release_time) self.end_release_time = asdatetime(end_release_time) self.num_elements=num_elements
def release_time(self, val): val = asdatetime(val) self.initial_release.release_time = val self.continuous.release_time = val
def test_asdatetime_none(): """ None should get passed through as well """ dt = asdatetime(None) assert dt is None
def test_asdatetime_dt(): dt = datetime(2010, 6, 1, 12, 30) dt2 = asdatetime(dt) assert dt == dt2 # they should be the same object assert dt is dt2
def release_time(self, rt): self._release_time = asdatetime(rt)
print 'Adding current' model.movers += current_mover print 'Adding RandomMover' model.movers += gs.RandomMover(diffusion_coeff=50000) print 'adding a wind mover:' model.movers += gs.constant_wind_mover(**Wind) print 'adding spill' spill = gs.surface_point_line_spill(num_elements=100, start_position=SpillPosition, end_position=(SpillPosition[0], SpillPosition[1] - 0.1, 0), release_time=asdatetime(start_time), amount=5000, units='kg', name='My spill') model.spills += spill model.outputters += gs.NetCDFOutput(os.path.join(out_dir, 'test_output.nc'), which_data='most', output_timestep=dT_OUT) renderer = gs.Renderer( output_timestep=dT_OUT, map_filename=mapfile, output_dir=out_dir, formats=['gif'], # ['gif', 'png'] image_size=(1280, 1024),
def __init__(self, release_time=None, start_position=None, num_elements=None, num_per_timestep=None, end_release_time=None, end_position=None, _next_release_pos=None, **kwargs): """ Required Arguments: :param release_time: time the LEs are released (datetime object) :type release_time: datetime.datetime :param start_position: initial location the elements are released :type start_position: 3-tuple of floats (long, lat, z) Optional arguments: .. note:: Either num_elements or num_per_timestep must be given. If both are None, then it defaults to num_elements=1000. If both are given a TypeError is raised because user can only specify one or the other, not both. :param num_elements: total number of elements to be released :type num_elements: integer :param num_per_timestep: fixed number of LEs released at each timestep :type num_elements: integer :param end_release_time=None: optional -- for a time varying release, the end release time. If None, then release is instantaneous :type end_release_time: datetime.datetime :param end_position=None: optional. For moving source, the end position If None, then release from a point source :type end_position: 3-tuple of floats (long, lat, z) num_elements and release_time passed to base class __init__ using super See base :class:`Release` documentation """ super(PointLineRelease, self).__init__(release_time=release_time, num_elements=num_elements, **kwargs) if num_elements is None and num_per_timestep is None: num_elements = 1000 if num_elements is not None and num_per_timestep is not None: msg = ('Either num_elements released or a release rate, defined by' ' num_per_timestep must be given, not both') raise TypeError(msg) self._num_per_timestep = num_per_timestep # initializes internal variables: _end_release_time, _start_position, # _end_position self.end_release_time = asdatetime(end_release_time) self.start_position = start_position self.end_position = end_position # need this for a line release self._next_release_pos = self.start_position if _next_release_pos is None else _next_release_pos # set this the first time it is used self._delta_pos = None self._reference_to_num_elements_to_release()
def test_asdatetime_str3(): dt = asdatetime("2010-06-01") assert isinstance(dt, datetime) assert dt == datetime(2010, 6, 1)
def end_release_time(self, rt): self.release.end_release_time = asdatetime(rt)