Exemplo n.º 1
0
    def image(self, state):
        if not self.valid(state):
            return gridded_forecast.empty_image()

        try:
            path, pts = self.locator.locate(self.pattern, state.variable,
                                            state.initial_time,
                                            state.valid_time, state.pressure)
        except SearchFail:
            print("Search failed: {}".format(self.pattern))
            return gridded_forecast.empty_image()

        print(path, pts)

        units = self.read_units(path, state.variable)
        data = load_image_pts(path, state.variable, pts, pts)
        if (len(state.pressures) > 0) and (state.pressure is not None):
            level = "{} hPa".format(int(state.pressure))
        else:
            level = "Surface"
        data.update(
            gridded_forecast.coordinates(state.valid_time, state.initial_time,
                                         state.pressures, state.pressure))
        data["name"] = [self.name]
        data["units"] = [units]
        return data
Exemplo n.º 2
0
    def image(self, state):
        '''gets actual data. 

        X and Y passed to :meth:`geo.stretch_image` must be 1D arrays. NWCSAF data 
        are not on a regular grid so must be regridded.

        `values` passed to :meth:`geo.stretch_image` must be a NumPy Masked Array. 

        :param state: Bokeh State object of info from UI
        :returns: Output data from :meth:`geo.stretch_image`'''
        data = empty_image()
        for nc in self.locator._sets:
            if str(
                    datetime.datetime.strptime(
                        nc.nominal_product_time.replace('Z', 'UTC'),
                        '%Y-%m-%dT%H:%M:%S%Z')
            ) == state.valid_time and self.locator.varlist[
                    state.variable] in nc.variables:
                #regrid to regular grid
                x = nc['lon'][:].flatten()  # lat & lon both 2D arrays
                y = nc['lat'][:].flatten()  #
                z = nc[self.locator.varlist[state.variable]][:].flatten()

                #define grid
                xi, yi = np.meshgrid(
                    np.linspace(x.min(), x.max(), nc.dimensions['nx'].size),
                    np.linspace(y.min(), y.max(), nc.dimensions['ny'].size),
                )

                zi = griddata(np.array([x, y]).transpose(),
                              z, (xi, yi),
                              method='linear',
                              fill_value=np.nan)

                zi = np.ma.masked_invalid(zi, copy=False)
                zi = np.ma.masked_outside(
                    zi,
                    nc[self.locator.varlist[state.variable]].valid_range[0],
                    nc[self.locator.varlist[state.variable]].valid_range[1],
                    copy=False)
                data = geo.stretch_image(xi[0, :], yi[:, 0], zi)
                #data = geo.stretch_image(x[0,:], y[:,0], nc[state.variable][:])
                data.update(
                    coordinates(state.valid_time, state.initial_time,
                                state.pressures, state.pressure))
                data.update({
                    'name':
                    [str(nc[self.locator.varlist[state.variable]].long_name)],
                })
                if 'units' in nc[self.locator.varlist[
                        state.variable]].ncattrs():
                    data.update({
                        'units':
                        [str(nc[self.locator.varlist[state.variable]].units)]
                    })

        return data
Exemplo n.º 3
0
    def test_surface_and_times(self, to_datetime):
        valid = datetime(2019, 10, 10, 9)
        initial = datetime(2019, 10, 10, 3)
        to_datetime.side_effect = [valid, initial]

        result = gridded_forecast.coordinates(sentinel.valid, sentinel.initial,
                                              [], None)

        self.assertEqual(to_datetime.mock_calls,
                         [call(sentinel.valid),
                          call(sentinel.initial)])
        self.assertEqual(
            result, {
                'valid': [valid],
                'initial': [initial],
                'length': ['T+6'],
                'level': ['Surface']
            })
Exemplo n.º 4
0
    def image(self, state):
        """
        Main image loading function. This function will actually realise the
        data,
        """
        if self.variable_id != state.variable:
            self.variable_id = state.variable
            self._cube = None

        valid_time = state.valid_time
        pressure = state.pressure

        selected_time = gridded_forecast._to_datetime(valid_time)

        # the guts of creating the bokeh object has been put into a separate
        # function so that it can be cached, so if image is called multiple
        # time the calculations are only done once (hopefully).
        cube = self.cube
        coord_names = [c1.name() for c1 in cube.coords()]
        if 'air_pressure' in coord_names and pressure is None:
            data = gridded_forecast.empty_image()
            return data

        data = _get_bokeh_image(cube, self.experiment_id,
                                self.variable_id,
                                self.institution_id, state.initial_time,
                                self.member_id, selected_time, pressure)

        data.update(gridded_forecast.coordinates(str(selected_time),
                                                 state.initial_time,
                                                 state.pressures,
                                                 pressure))
        data.update({
            'name': [self._label],
            'units': [str(cube.units)],
            'experiment': [self.experiment_id],
            'institution': [self.institution_id],
            'memberid': [self.member_id],
            'variableid': [self.variable_id]
        })

        return data
Exemplo n.º 5
0
    def test_pressure(self, to_datetime):
        result = gridded_forecast.coordinates(None, None, [1000, 900], 900)

        self.assertEqual(result['level'], ['900 hPa'])
Exemplo n.º 6
0
    def test_surface_no_pressure(self, to_datetime):
        result = gridded_forecast.coordinates(None, None, [1000, 900], None)

        self.assertEqual(result['level'], ['Surface'])