class GridWindMover(WindMoversBase):
_schema = GridWindMoverSchema
def __init__(self,
filename=None,
topology_file=None,
extrapolate=False,
time_offset=0,
**kwargs):
"""
:param wind_file: file containing wind data on a grid
:param filename: file containing wind data on a grid
:param topology_file: Default is None. When exporting topology, it
is stored in this file
:param wind_scale: Value to scale wind data
:param extrapolate: Allow current data to be extrapolated before and
after file data
:param time_offset: Time zone shift if data is in GMT
Pass optional arguments to base class
uses super: super(GridWindMover,self).__init__(\*\*kwargs)
"""
if not os.path.exists(filename):
raise ValueError(
'Path for wind 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))
self.mover = CyGridWindMover(wind_scale=kwargs.pop('wind_scale', 1))
self.mover.text_read(filename, topology_file)
# Ideally, we would be able to run the base class initialization first
# because we designed the Movers well. As it is, we inherit from the
# CyMover, and the CyMover needs to have a self.mover attribute.
super(GridWindMover, self).__init__(**kwargs)
# is wind_file and topology_file is stored with cy_gridwind_mover?
self.name = os.path.split(filename)[1]
self.filename = filename
self.topology_file = topology_file
self.mover.extrapolate_in_time(extrapolate)
self.mover.offset_time(time_offset * 3600.)
@property
def data_start(self):
return sec_to_datetime(self.mover.get_start_time())
@property
def data_stop(self):
return sec_to_datetime(self.mover.get_end_time())
def __repr__(self):
"""
.. todo::
We probably want to include more information.
"""
return 'GridWindMover(\n{0})'.format(self._state_as_str())
def __str__(self):
return ('GridWindMover - current _state.\n{0}'.format(
self._state_as_str()))
wind_scale = property(
lambda self: self.mover.wind_scale,
lambda self, val: setattr(self.mover, 'wind_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):
return self.get_cells()
def get_cells(self):
"""
Invokes the GetCellDataHdl method of TimeGridWind_c object.
Cross-references point data to get cell coordinates.
"""
cell_data = self.mover._get_cell_data()
points = self.get_points()
dtype = cell_data[0].dtype.descr
unstructured_type = dtype[0][1]
unstructured = (cell_data.view(dtype=unstructured_type).reshape(
-1, len(dtype))[:, 1:])
return points[unstructured]
def get_points(self):
points = (self.mover._get_points().astype([('long', '<f8'),
('lat', '<f8')]))
points['long'] /= 10**6
points['lat'] /= 10**6
return points
def get_cell_center_points(self):
'''
Right now the cython mover only gets the triangular center points,
so we need to calculate centers based on the cells themselves.
Cells will have the format (tl, tr, bl, br)
We need to get the rectangular centers
Center will be: (tl + ((br - tl) / 2.))
'''
return (self.mover._get_center_points().view(dtype='<f8').reshape(
-1, 2))
def get_center_points(self):
return self.get_cell_center_points()
def get_scaled_velocities(self, time):
"""
:param model_time=0:
"""
# regular and curvilinear grids only
if self.mover._is_regular_grid():
num_cells = self.mover.get_num_points()
else:
num_tri = self.mover.get_num_triangles()
num_cells = num_tri / 2
# will need to update this for regular grids
vels = np.zeros(num_cells, dtype=velocity_rec)
self.mover.get_scaled_velocities(time, vels)
return vels
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)
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.)
class GridWindMover(WindMoversBase, serializable.Serializable):
_state = copy.deepcopy(WindMoversBase._state)
_state.add(update=['wind_scale', 'extrapolate'],
save=['wind_scale', 'extrapolate'])
_state.add_field([
serializable.Field('wind_file',
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 = GridWindMoverSchema
def __init__(self,
wind_file,
topology_file=None,
extrapolate=False,
time_offset=0,
**kwargs):
"""
:param wind_file: file containing wind data on a grid
:param topology_file: Default is None. When exporting topology, it
is stored in this file
:param wind_scale: Value to scale wind data
:param extrapolate: Allow current data to be extrapolated before and
after file data
:param time_offset: Time zone shift if data is in GMT
Pass optional arguments to base class
uses super: super(GridWindMover,self).__init__(\*\*kwargs)
"""
if not os.path.exists(wind_file):
raise ValueError(
'Path for wind file does not exist: {0}'.format(wind_file))
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))
# is wind_file and topology_file is stored with cy_gridwind_mover?
self.wind_file = wind_file
self.topology_file = topology_file
self.mover = CyGridWindMover(wind_scale=kwargs.pop('wind_scale', 1))
self.name = os.path.split(wind_file)[1]
super(GridWindMover, self).__init__(**kwargs)
self.mover.text_read(wind_file, topology_file)
self.real_data_start = time_utils.sec_to_datetime(
self.mover.get_start_time())
self.real_data_stop = time_utils.sec_to_datetime(
self.mover.get_end_time())
self.mover.extrapolate_in_time(extrapolate)
self.mover.offset_time(time_offset * 3600.)
def __repr__(self):
"""
.. todo::
We probably want to include more information.
"""
info = 'GridWindMover(\n{0})'.format(self._state_as_str())
return info
def __str__(self):
info = ('GridWindMover - current _state.\n'
'{0}'.format(self._state_as_str()))
return info
wind_scale = property(
lambda self: self.mover.wind_scale,
lambda self, val: setattr(self.mover, 'wind_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 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)
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_start_time(self):
"""
:this will be the real_data_start time (seconds).
"""
return (self.mover.get_start_time())
def get_end_time(self):
"""
:this will be the real_data_stop time (seconds).
"""
return (self.mover.get_end_time())
class GridWindMover(WindMoversBase, serializable.Serializable):
_state = copy.deepcopy(WindMoversBase._state)
_state.add(update=['wind_scale', 'extrapolate'], save=['wind_scale', 'extrapolate'])
_state.add_field([serializable.Field('wind_file', 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 = GridWindMoverSchema
def __init__(self, wind_file, topology_file=None,
extrapolate=False, time_offset=0,
**kwargs):
"""
:param wind_file: file containing wind data on a grid
:param topology_file: Default is None. When exporting topology, it
is stored in this file
:param wind_scale: Value to scale wind data
:param extrapolate: Allow current data to be extrapolated before and
after file data
:param time_offset: Time zone shift if data is in GMT
Pass optional arguments to base class
uses super: super(GridWindMover,self).__init__(\*\*kwargs)
"""
if not os.path.exists(wind_file):
raise ValueError('Path for wind file does not exist: {0}'
.format(wind_file))
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))
# is wind_file and topology_file is stored with cy_gridwind_mover?
self.wind_file = wind_file
self.topology_file = topology_file
self.mover = CyGridWindMover(wind_scale=kwargs.pop('wind_scale', 1))
self.name = os.path.split(wind_file)[1]
super(GridWindMover, self).__init__(**kwargs)
self.mover.text_read(wind_file, topology_file)
self.real_data_start = time_utils.sec_to_datetime(self.mover.get_start_time())
self.real_data_stop = time_utils.sec_to_datetime(self.mover.get_end_time())
self.mover.extrapolate_in_time(extrapolate)
self.mover.offset_time(time_offset * 3600.)
def __repr__(self):
"""
.. todo::
We probably want to include more information.
"""
info = 'GridWindMover(\n{0})'.format(self._state_as_str())
return info
def __str__(self):
info = ('GridWindMover - current _state.\n'
'{0}'.format(self._state_as_str()))
return info
wind_scale = property(lambda self: self.mover.wind_scale,
lambda self, val: setattr(self.mover,
'wind_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 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)
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_start_time(self):
"""
:this will be the real_data_start time (seconds).
"""
return (self.mover.get_start_time())
def get_end_time(self):
"""
:this will be the real_data_stop time (seconds).
"""
return (self.mover.get_end_time())
class GridWindMover(WindMoversBase):
_schema = GridWindMoverSchema
def __init__(self, filename=None, topology_file=None,
extrapolate=False, time_offset=0,
**kwargs):
"""
:param wind_file: file containing wind data on a grid
:param filename: file containing wind data on a grid
:param topology_file: Default is None. When exporting topology, it
is stored in this file
:param wind_scale: Value to scale wind data
:param extrapolate: Allow current data to be extrapolated before and
after file data
:param time_offset: Time zone shift if data is in GMT
Pass optional arguments to base class
uses super: super(GridWindMover,self).__init__(\*\*kwargs)
"""
if not os.path.exists(filename):
raise ValueError('Path for wind 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))
self.mover = CyGridWindMover(wind_scale=kwargs.pop('wind_scale', 1))
self.mover.text_read(filename, topology_file)
# Ideally, we would be able to run the base class initialization first
# because we designed the Movers well. As it is, we inherit from the
# CyMover, and the CyMover needs to have a self.mover attribute.
super(GridWindMover, self).__init__(**kwargs)
# is wind_file and topology_file is stored with cy_gridwind_mover?
self.name = os.path.split(filename)[1]
self.filename = filename
self.topology_file = topology_file
self.mover.extrapolate_in_time(extrapolate)
self.mover.offset_time(time_offset * 3600.)
@property
def data_start(self):
return sec_to_datetime(self.mover.get_start_time())
@property
def data_stop(self):
return sec_to_datetime(self.mover.get_end_time())
def __repr__(self):
"""
.. todo::
We probably want to include more information.
"""
return 'GridWindMover(\n{0})'.format(self._state_as_str())
def __str__(self):
return ('GridWindMover - current _state.\n{0}'
.format(self._state_as_str()))
wind_scale = property(lambda self: self.mover.wind_scale,
lambda self, val: setattr(self.mover, 'wind_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):
return self.get_cells()
def get_cells(self):
"""
Invokes the GetCellDataHdl method of TimeGridWind_c object.
Cross-references point data to get cell coordinates.
"""
cell_data = self.mover._get_cell_data()
points = self.get_points()
dtype = cell_data[0].dtype.descr
unstructured_type = dtype[0][1]
unstructured = (cell_data.view(dtype=unstructured_type)
.reshape(-1, len(dtype))[:, 1:])
return points[unstructured]
def get_points(self):
points = (self.mover._get_points()
.astype([('long', '<f8'), ('lat', '<f8')]))
points['long'] /= 10 ** 6
points['lat'] /= 10 ** 6
return points
def get_cell_center_points(self):
'''
Right now the cython mover only gets the triangular center points,
so we need to calculate centers based on the cells themselves.
Cells will have the format (tl, tr, bl, br)
We need to get the rectangular centers
Center will be: (tl + ((br - tl) / 2.))
'''
return (self.mover._get_center_points()
.view(dtype='<f8').reshape(-1, 2))
def get_center_points(self):
return self.get_cell_center_points()
def get_scaled_velocities(self, time):
"""
:param model_time=0:
"""
# regular and curvilinear grids only
if self.mover._is_regular_grid():
num_cells = self.mover.get_num_points()
else:
num_tri = self.mover.get_num_triangles()
num_cells = num_tri / 2
# will need to update this for regular grids
vels = np.zeros(num_cells, dtype=velocity_rec)
self.mover.get_scaled_velocities(time, vels)
return vels
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)
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.)
class GridWindMover(WindMoversBase, serializable.Serializable):
_state = copy.deepcopy(WindMoversBase._state)
_state.add(update=["wind_scale"], create=["wind_scale"])
_state.add_field(
[
serializable.Field("wind_file", create=True, read=True, isdatafile=True, test_for_eq=False),
serializable.Field("topology_file", create=True, read=True, isdatafile=True, test_for_eq=False),
]
)
def __init__(self, wind_file, topology_file=None, extrapolate=False, time_offset=0, **kwargs):
"""
:param wind_file: file containing wind data on a grid
:param topology_file: Default is None. When exporting topology, it
is stored in this file
:param wind_scale: Value to scale wind data
:param extrapolate: Allow current data to be extrapolated before and
after file data
:param time_offset: Time zone shift if data is in GMT
Pass optional arguments to base class
uses super: super(GridWindMover,self).__init__(**kwargs)
"""
if not os.path.exists(wind_file):
raise ValueError("Path for wind file does not exist: {0}".format(wind_file))
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))
# is wind_file and topology_file is stored with cy_gridwind_mover?
self.wind_file = wind_file
self.topology_file = topology_file
self.mover = CyGridWindMover(wind_scale=kwargs.pop("wind_scale", 1))
super(GridWindMover, self).__init__(**kwargs)
self.mover.text_read(wind_file, topology_file)
self.mover.extrapolate_in_time(extrapolate)
self.mover.offset_time(time_offset * 3600.0)
def __repr__(self):
"""
.. todo::
We probably want to include more information.
"""
info = "GridWindMover(\n{0})".format(self._state_as_str())
return info
def __str__(self):
info = "GridWindMover - current _state.\n" "{0}".format(self._state_as_str())
return info
wind_scale = property(lambda self: self.mover.wind_scale, lambda self, val: setattr(self.mover, "wind_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.0, lambda self, val: setattr(self.mover, "time_offset", val * 3600.0)
)
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)
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.0)
class GridWindMover(WindMoversBase, serializable.Serializable):
state = copy.deepcopy(WindMoversBase.state)
state.add_field([serializable.Field('wind_file', create=True,
read=True, isdatafile=True),
serializable.Field('topology_file', create=True,
read=True, isdatafile=True)])
def __init__(
self,
wind_file,
topology_file=None,
**kwargs
):
"""
:param wind_file: file containing wind data on a grid
:param topology_file: Default is None. When exporting topology, it
is stored in this file
Pass optional arguments to base class
uses super: super(GridWindMover,self).__init__(**kwargs)
"""
if not os.path.exists(wind_file):
raise ValueError('Path for wind file does not exist: {0}'
.format(wind_file))
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))
# is wind_file and topology_file is stored with cy_gridwind_mover?
self.wind_file = wind_file
self.topology_file = topology_file
self.mover = CyGridWindMover()
super(GridWindMover, self).__init__(**kwargs)
self.mover.text_read(wind_file, topology_file)
def __repr__(self):
"""
.. todo::
We probably want to include more information.
"""
info = 'GridWindMover(\n{0})'.format(self._state_as_str())
return info
def __str__(self):
info = 'GridWindMover - current state.\n' \
+ "{0}".format(self._state_as_str())
return info
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)