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, 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 __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 release_time(self, val):
val = asdatetime(val)
self.initial_release.release_time = val
self.continuous.release_time = val
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)