def __init__(self,
filename=None,
topology_file=None,
extrapolate=False,
time_offset=0,
**kwargs):
"""
Initialize an IceMover
:param filename: absolute or relative path to the data file:
could be netcdf or filelist
:param topology_file=None: absolute or relative path to topology file.
If not given, the IceMover will
compute the topology from the data file.
:param active_start: datetime when the mover should be active
:param active_stop: datetime after which the mover should be inactive
:param current_scale: Value to scale current data
:param uncertain_duration: how often does a given uncertain element
get reset
:param uncertain_time_delay: when does the uncertainly kick in.
:param uncertain_cross: Scale for uncertainty perpendicular to the flow
:param uncertain_along: Scale for uncertainty parallel to the flow
:param extrapolate: Allow current data to be extrapolated
before and after file data
:param time_offset: Time zone shift if data is in GMT
uses super, super(IceMover,self).__init__(\*\*kwargs)
"""
# NOTE: will need to add uncertainty parameters and other dialog fields
# use super with kwargs to invoke base class __init__
# if child is calling, the self.mover is set by child - do not reset
if type(self) == IceMover:
self.mover = CyIceMover()
if not os.path.exists(filename):
raise ValueError(
'Path for current file does not exist: {0}'.format(filename))
if topology_file is not None:
if not os.path.exists(topology_file):
raise ValueError(
'Path for Topology file does not exist: {0}'.format(
topology_file))
# check if this is stored with cy_ice_mover?
self.filename = filename
self.name = os.path.split(filename)[1]
# check if this is stored with cy_ice_mover?
self.topology_file = topology_file
self.mover.text_read(filename, topology_file)
self.extrapolate = extrapolate
self.mover.extrapolate_in_time(extrapolate)
self.mover.offset_time(time_offset * 3600.)
super(IceMover, self).__init__(**kwargs)
def __init__(self, filename,
topology_file=None,
extrapolate=False,
time_offset=0,
**kwargs):
"""
Initialize an IceMover
:param filename: absolute or relative path to the data file:
could be netcdf or filelist
:param topology_file=None: absolute or relative path to topology file.
If not given, the IceMover will
compute the topology from the data file.
:param active_start: datetime when the mover should be active
:param active_stop: datetime after which the mover should be inactive
:param current_scale: Value to scale current data
:param uncertain_duration: how often does a given uncertain element
get reset
:param uncertain_time_delay: when does the uncertainly kick in.
:param uncertain_cross: Scale for uncertainty perpendicular to the flow
:param uncertain_along: Scale for uncertainty parallel to the flow
:param extrapolate: Allow current data to be extrapolated
before and after file data
:param time_offset: Time zone shift if data is in GMT
uses super, super(IceMover,self).__init__(\*\*kwargs)
"""
# NOTE: will need to add uncertainty parameters and other dialog fields
# use super with kwargs to invoke base class __init__
# if child is calling, the self.mover is set by child - do not reset
if type(self) == IceMover:
self.mover = CyIceMover()
if not os.path.exists(filename):
raise ValueError('Path for current file does not exist: {0}'
.format(filename))
if topology_file is not None:
if not os.path.exists(topology_file):
raise ValueError('Path for Topology file does not exist: {0}'
.format(topology_file))
# check if this is stored with cy_ice_mover?
self.filename = filename
self.name = os.path.split(filename)[1]
# check if this is stored with cy_ice_mover?
self.topology_file = topology_file
self.mover.text_read(filename, topology_file)
self.extrapolate = extrapolate
self.mover.extrapolate_in_time(extrapolate)
self.mover.offset_time(time_offset * 3600.)
super(IceMover, self).__init__(**kwargs)
class IceMover(CurrentMoversBase):
_schema = IceMoverSchema
def __init__(self,
filename=None,
topology_file=None,
current_scale=1,
uncertain_along=0.5,
uncertain_cross=0.25,
extrapolate=False,
time_offset=0,
**kwargs):
"""
Initialize an IceMover
:param filename: absolute or relative path to the data file:
could be netcdf or filelist
:param topology_file=None: absolute or relative path to topology file.
If not given, the IceMover will
compute the topology from the data file.
:param active_range: Range of datetimes for when the mover should be
active
:type active_range: 2-tuple of datetimes
:param current_scale: Value to scale current data
:param uncertain_duration: how often does a given uncertain element
get reset
:param uncertain_time_delay: when does the uncertainly kick in.
:param uncertain_cross: Scale for uncertainty perpendicular to the flow
:param uncertain_along: Scale for uncertainty parallel to the flow
:param extrapolate: Allow current data to be extrapolated
before and after file data
:param time_offset: Time zone shift if data is in GMT
uses super, super(IceMover,self).__init__(\*\*kwargs)
"""
# NOTE: will need to add uncertainty parameters and other dialog fields
# use super with kwargs to invoke base class __init__
# if child is calling, the self.mover is set by child - do not reset
if type(self) == IceMover:
self.mover = CyIceMover()
if not os.path.exists(filename):
raise ValueError(
'Path for current file does not exist: {0}'.format(filename))
if topology_file is not None:
if not os.path.exists(topology_file):
raise ValueError(
'Path for Topology file does not exist: {0}'.format(
topology_file))
# check if this is stored with cy_ice_mover?
self.filename = filename
self.name = os.path.split(filename)[1]
# check if this is stored with cy_ice_mover?
self.topology_file = topology_file
self.mover.text_read(filename, topology_file)
self.extrapolate = extrapolate
self.mover.extrapolate_in_time(extrapolate)
self.mover.offset_time(time_offset * 3600.)
self.uncertain_along = uncertain_along
self.uncertain_cross = uncertain_cross
self.current_scale = current_scale
super(IceMover, self).__init__(**kwargs)
def __repr__(self):
return ('IceMover('
'uncertain_duration={0.uncertain_duration}, '
'uncertain_time_delay={0.uncertain_time_delay}, '
'uncertain_cross={0.uncertain_cross}, '
'uncertain_along={0.uncertain_along}, '
'active_range={1.active_range}, '
'on={1.on})'.format(self.mover, self))
def __str__(self):
return ('IceMover - current _state.\n'
' uncertain_duration={0.uncertain_duration}\n'
' uncertain_time_delay={0.uncertain_time_delay}\n'
' uncertain_cross={0.uncertain_cross}\n'
' uncertain_along={0.uncertain_along}\n'
' active_range time={1.active_range}\n'
' current on/off status={1.on}'.format(self.mover, self))
# Define properties using lambda functions: uses lambda function, which are
# accessible via fget/fset as follows:
uncertain_cross = property(
lambda self: self.mover.uncertain_cross,
lambda self, val: setattr(self.mover, 'uncertain_cross', val))
uncertain_along = property(
lambda self: self.mover.uncertain_along,
lambda self, val: setattr(self.mover, 'uncertain_along', val))
current_scale = property(
lambda self: self.mover.current_scale,
lambda self, val: setattr(self.mover, 'current_scale', val))
extrapolate = property(
lambda self: self.mover.extrapolate,
lambda self, val: setattr(self.mover, 'extrapolate', val))
time_offset = property(
lambda self: self.mover.time_offset / 3600.,
lambda self, val: setattr(self.mover, 'time_offset', val * 3600.))
def get_grid_data(self):
if self.mover._is_triangle_grid():
return self.get_triangles()
else:
return self.get_cells()
def get_grid_bounding_box(self, grid_data=None, box_to_merge=None):
'''
Return a bounding box surrounding the grid data.
:param grid_data: The point data of our grid.
:type grid_data: A sequence of 3-tuples or 4-tuples containing
(long, lat) pairs.
:param box_to_merge: A bounding box to surround in combination
with our grid data. This allows us to pad
the bounding box that we generate.
:type box_to_merge: A bounding box (extent) of the form:
((left, bottom),
(right, top))
'''
if grid_data is None:
grid_data = self.get_grid_data()
dtype = grid_data.dtype.descr
unstructured_type = dtype[0][1]
longs = (grid_data.view(dtype=unstructured_type).reshape(
-1, len(dtype))[:, 0])
lats = (grid_data.view(dtype=unstructured_type).reshape(
-1, len(dtype))[:, 1])
left, right = longs.min(), longs.max()
bottom, top = lats.min(), lats.max()
if (box_to_merge is not None and len(box_to_merge) == 2
and [len(p) for p in box_to_merge] == [2, 2]):
if left > box_to_merge[0][0]:
left = box_to_merge[0][0]
if right < box_to_merge[1][0]:
right = box_to_merge[1][0]
if bottom > box_to_merge[0][1]:
bottom = box_to_merge[0][1]
if top < box_to_merge[1][1]:
top = box_to_merge[1][1]
return ((left, bottom), (right, top))
def get_center_points(self):
if self.mover._is_triangle_grid():
return self.get_triangle_center_points()
else:
return self.get_cell_center_points()
def get_scaled_velocities(self, model_time):
"""
:param model_time=0:
"""
num_tri = self.mover.get_num_triangles()
if self.mover._is_triangle_grid():
num_cells = num_tri
else:
num_cells = num_tri / 2
vels = np.zeros(num_cells, dtype=basic_types.velocity_rec)
self.mover.get_scaled_velocities(model_time, vels)
return vels
def get_ice_velocities(self, model_time):
"""
:param model_time=0:
"""
num_tri = self.mover.get_num_triangles()
vels = np.zeros(num_tri, dtype=basic_types.velocity_rec)
self.mover.get_ice_velocities(model_time, vels)
return vels
def get_movement_velocities(self, model_time):
"""
:param model_time=0:
"""
num_tri = self.mover.get_num_triangles()
vels = np.zeros(num_tri, dtype=basic_types.velocity_rec)
self.mover.get_movement_velocities(model_time, vels)
return vels
def get_ice_fields(self, model_time):
"""
:param model_time=0:
"""
num_tri = self.mover.get_num_triangles()
num_cells = num_tri / 2
frac_coverage = np.zeros(num_cells, dtype=np.float64)
thickness = np.zeros(num_cells, dtype=np.float64)
self.mover.get_ice_fields(model_time, frac_coverage, thickness)
return frac_coverage, thickness
def export_topology(self, topology_file):
"""
:param topology_file=None: absolute or relative path where
topology file will be written.
"""
if topology_file is None:
raise ValueError(
'Topology file path required: {0}'.format(topology_file))
self.mover.export_topology(topology_file)
def extrapolate_in_time(self, extrapolate):
"""
:param extrapolate=false: allow current data to be extrapolated
before and after file data.
"""
self.mover.extrapolate_in_time(extrapolate)
self.extrapolate = extrapolate
def offset_time(self, time_offset):
"""
:param offset_time=0: allow data to be in GMT with a time zone offset
(hours).
"""
self.mover.offset_time(time_offset * 3600.)
def get_offset_time(self):
"""
:param offset_time=0: allow data to be in GMT with a time zone offset
(hours).
"""
return (self.mover.get_offset_time()) / 3600.
class IceMover(CurrentMoversBase):
_schema = IceMoverSchema
def __init__(self,
filename=None,
topology_file=None,
current_scale=1,
uncertain_along=0.5,
uncertain_cross=0.25,
extrapolate=False,
time_offset=0,
**kwargs):
"""
Initialize an IceMover
:param filename: absolute or relative path to the data file:
could be netcdf or filelist
:param topology_file=None: absolute or relative path to topology file.
If not given, the IceMover will
compute the topology from the data file.
:param active_range: Range of datetimes for when the mover should be
active
:type active_range: 2-tuple of datetimes
:param current_scale: Value to scale current data
:param uncertain_duration: how often does a given uncertain element
get reset
:param uncertain_time_delay: when does the uncertainly kick in.
:param uncertain_cross: Scale for uncertainty perpendicular to the flow
:param uncertain_along: Scale for uncertainty parallel to the flow
:param extrapolate: Allow current data to be extrapolated
before and after file data
:param time_offset: Time zone shift if data is in GMT
uses super, super(IceMover,self).__init__(\*\*kwargs)
"""
# NOTE: will need to add uncertainty parameters and other dialog fields
# use super with kwargs to invoke base class __init__
# if child is calling, the self.mover is set by child - do not reset
if type(self) == IceMover:
self.mover = CyIceMover()
if not os.path.exists(filename):
raise ValueError('Path for current file does not exist: {0}'
.format(filename))
if topology_file is not None:
if not os.path.exists(topology_file):
raise ValueError('Path for Topology file does not exist: {0}'
.format(topology_file))
# check if this is stored with cy_ice_mover?
self.filename = filename
self.name = os.path.split(filename)[1]
# check if this is stored with cy_ice_mover?
self.topology_file = topology_file
self.mover.text_read(filename, topology_file)
self.extrapolate = extrapolate
self.mover.extrapolate_in_time(extrapolate)
self.mover.offset_time(time_offset * 3600.)
self.uncertain_along = uncertain_along
self.uncertain_cross = uncertain_cross
self.current_scale = current_scale
super(IceMover, self).__init__(**kwargs)
def __repr__(self):
return ('IceMover('
'uncertain_duration={0.uncertain_duration}, '
'uncertain_time_delay={0.uncertain_time_delay}, '
'uncertain_cross={0.uncertain_cross}, '
'uncertain_along={0.uncertain_along}, '
'active_range={1.active_range}, '
'on={1.on})'
.format(self.mover, self))
def __str__(self):
return ('IceMover - current _state.\n'
' uncertain_duration={0.uncertain_duration}\n'
' uncertain_time_delay={0.uncertain_time_delay}\n'
' uncertain_cross={0.uncertain_cross}\n'
' uncertain_along={0.uncertain_along}\n'
' active_range time={1.active_range}\n'
' current on/off status={1.on}'
.format(self.mover, self))
# Define properties using lambda functions: uses lambda function, which are
# accessible via fget/fset as follows:
uncertain_cross = property(lambda self: self.mover.uncertain_cross,
lambda self, val: setattr(self.mover,
'uncertain_cross',
val))
uncertain_along = property(lambda self: self.mover.uncertain_along,
lambda self, val: setattr(self.mover,
'uncertain_along',
val))
current_scale = property(lambda self: self.mover.current_scale,
lambda self, val: setattr(self.mover,
'current_scale',
val))
extrapolate = property(lambda self: self.mover.extrapolate,
lambda self, val: setattr(self.mover,
'extrapolate',
val))
time_offset = property(lambda self: self.mover.time_offset / 3600.,
lambda self, val: setattr(self.mover,
'time_offset',
val * 3600.))
def get_grid_data(self):
if self.mover._is_triangle_grid():
return self.get_triangles()
else:
return self.get_cells()
def get_grid_bounding_box(self, grid_data=None, box_to_merge=None):
'''
Return a bounding box surrounding the grid data.
:param grid_data: The point data of our grid.
:type grid_data: A sequence of 3-tuples or 4-tuples containing
(long, lat) pairs.
:param box_to_merge: A bounding box to surround in combination
with our grid data. This allows us to pad
the bounding box that we generate.
:type box_to_merge: A bounding box (extent) of the form:
((left, bottom),
(right, top))
'''
if grid_data is None:
grid_data = self.get_grid_data()
dtype = grid_data.dtype.descr
unstructured_type = dtype[0][1]
longs = (grid_data
.view(dtype=unstructured_type)
.reshape(-1, len(dtype))[:, 0])
lats = (grid_data
.view(dtype=unstructured_type)
.reshape(-1, len(dtype))[:, 1])
left, right = longs.min(), longs.max()
bottom, top = lats.min(), lats.max()
if (box_to_merge is not None and
len(box_to_merge) == 2 and
[len(p) for p in box_to_merge] == [2, 2]):
if left > box_to_merge[0][0]:
left = box_to_merge[0][0]
if right < box_to_merge[1][0]:
right = box_to_merge[1][0]
if bottom > box_to_merge[0][1]:
bottom = box_to_merge[0][1]
if top < box_to_merge[1][1]:
top = box_to_merge[1][1]
return ((left, bottom), (right, top))
def get_center_points(self):
if self.mover._is_triangle_grid():
return self.get_triangle_center_points()
else:
return self.get_cell_center_points()
def get_scaled_velocities(self, model_time):
"""
:param model_time=0:
"""
num_tri = self.mover.get_num_triangles()
if self.mover._is_triangle_grid():
num_cells = num_tri
else:
num_cells = num_tri / 2
vels = np.zeros(num_cells, dtype=basic_types.velocity_rec)
self.mover.get_scaled_velocities(model_time, vels)
return vels
def get_ice_velocities(self, model_time):
"""
:param model_time=0:
"""
num_tri = self.mover.get_num_triangles()
vels = np.zeros(num_tri, dtype=basic_types.velocity_rec)
self.mover.get_ice_velocities(model_time, vels)
return vels
def get_movement_velocities(self, model_time):
"""
:param model_time=0:
"""
num_tri = self.mover.get_num_triangles()
vels = np.zeros(num_tri, dtype=basic_types.velocity_rec)
self.mover.get_movement_velocities(model_time, vels)
return vels
def get_ice_fields(self, model_time):
"""
:param model_time=0:
"""
num_tri = self.mover.get_num_triangles()
num_cells = num_tri / 2
frac_coverage = np.zeros(num_cells, dtype=np.float64)
thickness = np.zeros(num_cells, dtype=np.float64)
self.mover.get_ice_fields(model_time, frac_coverage, thickness)
return frac_coverage, thickness
def export_topology(self, topology_file):
"""
:param topology_file=None: absolute or relative path where
topology file will be written.
"""
if topology_file is None:
raise ValueError('Topology file path required: {0}'
.format(topology_file))
self.mover.export_topology(topology_file)
def extrapolate_in_time(self, extrapolate):
"""
:param extrapolate=false: allow current data to be extrapolated
before and after file data.
"""
self.mover.extrapolate_in_time(extrapolate)
self.extrapolate = extrapolate
def offset_time(self, time_offset):
"""
:param offset_time=0: allow data to be in GMT with a time zone offset
(hours).
"""
self.mover.offset_time(time_offset * 3600.)
def get_offset_time(self):
"""
:param offset_time=0: allow data to be in GMT with a time zone offset
(hours).
"""
return (self.mover.get_offset_time()) / 3600.
class IceMover(CurrentMoversBase, serializable.Serializable):
_update = ['uncertain_cross', 'uncertain_along',
'current_scale', 'extrapolate']
_save = ['uncertain_cross', 'uncertain_along',
'current_scale', 'extrapolate']
_state = copy.deepcopy(CurrentMoversBase._state)
_state.add(update=_update, save=_save)
_state.add_field([serializable.Field('filename',
save=True, read=True, isdatafile=True,
test_for_eq=False),
serializable.Field('topology_file',
save=True, read=True, isdatafile=True,
test_for_eq=False)])
_schema = IceMoverSchema
def __init__(self, filename,
topology_file=None,
extrapolate=False,
time_offset=0,
**kwargs):
"""
Initialize an IceMover
:param filename: absolute or relative path to the data file:
could be netcdf or filelist
:param topology_file=None: absolute or relative path to topology file.
If not given, the IceMover will
compute the topology from the data file.
:param active_start: datetime when the mover should be active
:param active_stop: datetime after which the mover should be inactive
:param current_scale: Value to scale current data
:param uncertain_duration: how often does a given uncertain element
get reset
:param uncertain_time_delay: when does the uncertainly kick in.
:param uncertain_cross: Scale for uncertainty perpendicular to the flow
:param uncertain_along: Scale for uncertainty parallel to the flow
:param extrapolate: Allow current data to be extrapolated
before and after file data
:param time_offset: Time zone shift if data is in GMT
uses super, super(IceMover,self).__init__(\*\*kwargs)
"""
# NOTE: will need to add uncertainty parameters and other dialog fields
# use super with kwargs to invoke base class __init__
# if child is calling, the self.mover is set by child - do not reset
if type(self) == IceMover:
self.mover = CyIceMover()
if not os.path.exists(filename):
raise ValueError('Path for current file does not exist: {0}'
.format(filename))
if topology_file is not None:
if not os.path.exists(topology_file):
raise ValueError('Path for Topology file does not exist: {0}'
.format(topology_file))
# check if this is stored with cy_ice_mover?
self.filename = filename
self.name = os.path.split(filename)[1]
# check if this is stored with cy_ice_mover?
self.topology_file = topology_file
self.mover.text_read(filename, topology_file)
self.extrapolate = extrapolate
self.mover.extrapolate_in_time(extrapolate)
self.mover.offset_time(time_offset * 3600.)
super(IceMover, self).__init__(**kwargs)
def __repr__(self):
return ('IceMover('
'uncertain_duration={0.uncertain_duration}, '
'uncertain_time_delay={0.uncertain_time_delay}, '
'uncertain_cross={0.uncertain_cross}, '
'uncertain_along={0.uncertain_along}, '
'active_start={1.active_start}, '
'active_stop={1.active_stop}, '
'on={1.on})'.format(self.mover, self))
def __str__(self):
return ('IceMover - current _state.\n'
' uncertain_duration={0.uncertain_duration}\n'
' uncertain_time_delay={0.uncertain_time_delay}\n'
' uncertain_cross={0.uncertain_cross}\n'
' uncertain_along={0.uncertain_along}\n'
' active_start time={1.active_start}\n'
' active_stop time={1.active_stop}\n'
' current on/off status={1.on}'
.format(self.mover, self))
# Define properties using lambda functions: uses lambda function, which are
# accessible via fget/fset as follows:
uncertain_cross = property(lambda self: self.mover.uncertain_cross,
lambda self, val: setattr(self.mover,
'uncertain_cross',
val))
uncertain_along = property(lambda self: self.mover.uncertain_along,
lambda self, val: setattr(self.mover,
'uncertain_along',
val))
current_scale = property(lambda self: self.mover.current_scale,
lambda self, val: setattr(self.mover,
'current_scale',
val))
extrapolate = property(lambda self: self.mover.extrapolate,
lambda self, val: setattr(self.mover,
'extrapolate',
val))
time_offset = property(lambda self: self.mover.time_offset / 3600.,
lambda self, val: setattr(self.mover,
'time_offset',
val * 3600.))
def get_grid_data(self):
if self.mover._is_triangle_grid():
return self.get_triangles()
else:
return self.get_cells()
def get_center_points(self):
if self.mover._is_triangle_grid():
return self.get_triangle_center_points()
else:
return self.get_cell_center_points()
def get_scaled_velocities(self, model_time):
"""
:param model_time=0:
"""
num_tri = self.mover.get_num_triangles()
vels = np.zeros(num_tri, dtype=basic_types.velocity_rec)
self.mover.get_scaled_velocities(model_time, vels)
return vels
def get_ice_velocities(self, model_time):
"""
:param model_time=0:
"""
num_tri = self.mover.get_num_triangles()
vels = np.zeros(num_tri, dtype=basic_types.velocity_rec)
self.mover.get_ice_velocities(model_time, vels)
return vels
def get_movement_velocities(self, model_time):
"""
:param model_time=0:
"""
num_tri = self.mover.get_num_triangles()
vels = np.zeros(num_tri, dtype=basic_types.velocity_rec)
self.mover.get_movement_velocities(model_time, vels)
return vels
def get_ice_fields(self, model_time):
"""
:param model_time=0:
"""
num_tri = self.mover.get_num_triangles()
num_cells = num_tri / 2
frac_coverage = np.zeros(num_cells, dtype=np.float64)
thickness = np.zeros(num_cells, dtype=np.float64)
self.mover.get_ice_fields(model_time, frac_coverage, thickness)
return frac_coverage, thickness
def export_topology(self, topology_file):
"""
:param topology_file=None: absolute or relative path where
topology file will be written.
"""
if topology_file is None:
raise ValueError('Topology file path required: {0}'
.format(topology_file))
self.mover.export_topology(topology_file)
def extrapolate_in_time(self, extrapolate):
"""
:param extrapolate=false: allow current data to be extrapolated
before and after file data.
"""
self.mover.extrapolate_in_time(extrapolate)
self.extrapolate = extrapolate
def offset_time(self, time_offset):
"""
:param offset_time=0: allow data to be in GMT with a time zone offset
(hours).
"""
self.mover.offset_time(time_offset * 3600.)
def get_offset_time(self):
"""
:param offset_time=0: allow data to be in GMT with a time zone offset
(hours).
"""
return (self.mover.get_offset_time()) / 3600.
class IceMover(CurrentMoversBase, serializable.Serializable):
_update = [
'uncertain_cross', 'uncertain_along', 'current_scale', 'extrapolate'
]
_save = [
'uncertain_cross', 'uncertain_along', 'current_scale', 'extrapolate'
]
_state = copy.deepcopy(CurrentMoversBase._state)
_state.add(update=_update, save=_save)
_state.add_field([
serializable.Field('filename',
save=True,
read=True,
isdatafile=True,
test_for_eq=False),
serializable.Field('topology_file',
save=True,
read=True,
isdatafile=True,
test_for_eq=False)
])
_schema = IceMoverSchema
def __init__(self,
filename,
topology_file=None,
extrapolate=False,
time_offset=0,
**kwargs):
"""
Initialize an IceMover
:param filename: absolute or relative path to the data file:
could be netcdf or filelist
:param topology_file=None: absolute or relative path to topology file.
If not given, the IceMover will
compute the topology from the data file.
:param active_start: datetime when the mover should be active
:param active_stop: datetime after which the mover should be inactive
:param current_scale: Value to scale current data
:param uncertain_duration: how often does a given uncertain element
get reset
:param uncertain_time_delay: when does the uncertainly kick in.
:param uncertain_cross: Scale for uncertainty perpendicular to the flow
:param uncertain_along: Scale for uncertainty parallel to the flow
:param extrapolate: Allow current data to be extrapolated
before and after file data
:param time_offset: Time zone shift if data is in GMT
uses super, super(IceMover,self).__init__(\*\*kwargs)
"""
# NOTE: will need to add uncertainty parameters and other dialog fields
# use super with kwargs to invoke base class __init__
# if child is calling, the self.mover is set by child - do not reset
if type(self) == IceMover:
self.mover = CyIceMover()
if not os.path.exists(filename):
raise ValueError(
'Path for current file does not exist: {0}'.format(filename))
if topology_file is not None:
if not os.path.exists(topology_file):
raise ValueError(
'Path for Topology file does not exist: {0}'.format(
topology_file))
# check if this is stored with cy_ice_mover?
self.filename = filename
self.name = os.path.split(filename)[1]
# check if this is stored with cy_ice_mover?
self.topology_file = topology_file
self.mover.text_read(filename, topology_file)
self.extrapolate = extrapolate
self.mover.extrapolate_in_time(extrapolate)
self.mover.offset_time(time_offset * 3600.)
super(IceMover, self).__init__(**kwargs)
def __repr__(self):
return ('IceMover('
'uncertain_duration={0.uncertain_duration}, '
'uncertain_time_delay={0.uncertain_time_delay}, '
'uncertain_cross={0.uncertain_cross}, '
'uncertain_along={0.uncertain_along}, '
'active_start={1.active_start}, '
'active_stop={1.active_stop}, '
'on={1.on})'.format(self.mover, self))
def __str__(self):
return ('IceMover - current _state.\n'
' uncertain_duration={0.uncertain_duration}\n'
' uncertain_time_delay={0.uncertain_time_delay}\n'
' uncertain_cross={0.uncertain_cross}\n'
' uncertain_along={0.uncertain_along}\n'
' active_start time={1.active_start}\n'
' active_stop time={1.active_stop}\n'
' current on/off status={1.on}'.format(self.mover, self))
# Define properties using lambda functions: uses lambda function, which are
# accessible via fget/fset as follows:
uncertain_cross = property(
lambda self: self.mover.uncertain_cross,
lambda self, val: setattr(self.mover, 'uncertain_cross', val))
uncertain_along = property(
lambda self: self.mover.uncertain_along,
lambda self, val: setattr(self.mover, 'uncertain_along', val))
current_scale = property(
lambda self: self.mover.current_scale,
lambda self, val: setattr(self.mover, 'current_scale', val))
extrapolate = property(
lambda self: self.mover.extrapolate,
lambda self, val: setattr(self.mover, 'extrapolate', val))
time_offset = property(
lambda self: self.mover.time_offset / 3600.,
lambda self, val: setattr(self.mover, 'time_offset', val * 3600.))
def get_grid_data(self):
if self.mover._is_triangle_grid():
return self.get_triangles()
else:
return self.get_cells()
def get_center_points(self):
if self.mover._is_triangle_grid():
return self.get_triangle_center_points()
else:
return self.get_cell_center_points()
def get_scaled_velocities(self, model_time):
"""
:param model_time=0:
"""
num_tri = self.mover.get_num_triangles()
if self.mover._is_triangle_grid():
num_cells = num_tri
else:
num_cells = num_tri / 2
vels = np.zeros(num_cells, dtype=basic_types.velocity_rec)
self.mover.get_scaled_velocities(model_time, vels)
return vels
def get_ice_velocities(self, model_time):
"""
:param model_time=0:
"""
num_tri = self.mover.get_num_triangles()
vels = np.zeros(num_tri, dtype=basic_types.velocity_rec)
self.mover.get_ice_velocities(model_time, vels)
return vels
def get_movement_velocities(self, model_time):
"""
:param model_time=0:
"""
num_tri = self.mover.get_num_triangles()
vels = np.zeros(num_tri, dtype=basic_types.velocity_rec)
self.mover.get_movement_velocities(model_time, vels)
return vels
def get_ice_fields(self, model_time):
"""
:param model_time=0:
"""
num_tri = self.mover.get_num_triangles()
num_cells = num_tri / 2
frac_coverage = np.zeros(num_cells, dtype=np.float64)
thickness = np.zeros(num_cells, dtype=np.float64)
self.mover.get_ice_fields(model_time, frac_coverage, thickness)
return frac_coverage, thickness
def export_topology(self, topology_file):
"""
:param topology_file=None: absolute or relative path where
topology file will be written.
"""
if topology_file is None:
raise ValueError(
'Topology file path required: {0}'.format(topology_file))
self.mover.export_topology(topology_file)
def extrapolate_in_time(self, extrapolate):
"""
:param extrapolate=false: allow current data to be extrapolated
before and after file data.
"""
self.mover.extrapolate_in_time(extrapolate)
self.extrapolate = extrapolate
def offset_time(self, time_offset):
"""
:param offset_time=0: allow data to be in GMT with a time zone offset
(hours).
"""
self.mover.offset_time(time_offset * 3600.)
def get_offset_time(self):
"""
:param offset_time=0: allow data to be in GMT with a time zone offset
(hours).
"""
return (self.mover.get_offset_time()) / 3600.