예제 #1
0
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.)
예제 #2
0
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())
예제 #3
0
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())
예제 #4
0
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.)
예제 #5
0
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)
예제 #6
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)