verde.BlockReduce#

class verde.BlockReduce(reduction, spacing=None, region=None, adjust='spacing', center_coordinates=False, shape=None, drop_coords=True)[source]#

Apply a reduction/aggregation operation to the data in blocks/windows.

Returns the reduced data value for each block along with the associated coordinates, which can be determined through the same reduction applied to the coordinates or as the center of each block.

If a data region to be divided into blocks is not given, it will be the bounding region of the data. When using this class to decimate data before gridding, it’s best to use the same region and spacing as the desired grid.

The size of the blocks can be specified by the spacing parameter. Alternatively, the number of blocks in the South-North and West-East directions can be specified using the shape parameter.

If the given region is not divisible by the spacing (block size), either the region or the spacing will have to be adjusted. By default, the spacing will be rounded to the nearest multiple. Optionally, the East and North boundaries of the region can be adjusted to fit the exact spacing given.

Blocks without any data are omitted from the output.

Implements the filter method so it can be used with verde.Chain. Only acts during data fitting and is ignored during prediction.

Parameters:

reductionfunction: A reduction function that takes an array and returns a single value (e.g., np.mean, np.median, etc).
shapetuple = (n_north, n_east) or None: The number of blocks in the South-North and West-East directions, respectively.
spacingfloat, tuple = (s_north, s_east), or None: The block size in the South-North and West-East directions, respectively. A single value means that the size is equal in both directions.
regionlist = [W, E, S, N]: The boundaries of a given region in Cartesian or geographic coordinates.
adjust{‘spacing’, ‘region’}: Whether to adjust the spacing or the region if required. Ignored if shape is given instead of spacing. Defaults to adjusting the spacing.
center_coordinatesbool: If True, then the returned coordinates correspond to the center of each block. Otherwise, the coordinates are calculated by applying the same reduction operation to the input coordinates.
drop_coordsbool: If True, only the reduced easting and northing coordinates are returned, dropping any other ones. If False, all coordinates are reduced and returned. Default True.

Methods#

BlockReduce.filter(coordinates, data, weights=None)[source]#

Apply the blocked aggregation to the given data.

Returns the reduced data value for each block along with the associated coordinates, which can be determined through the same reduction applied to the coordinates or as the center of each block.

If weights are given, the reduction function must accept a weights keyword argument. The weights are passed in to the reduction but we have no generic way aggregating the weights or reporting uncertainties. For that, look to the specialized classes like verde.BlockMean.

Parameters:

coordinatestuple of arrays: Arrays with the coordinates of each data point. Should be in the following order: (easting, northing, vertical, …). Only easting and northing will be used to create the blocks. If drop_coords is False, all other coordinates will be reduced along with the data.
dataarray or tuple of arrays: The data values at each point. If you want to reduce more than one data component, pass in multiple arrays as elements of a tuple. All arrays must have the same shape.
weightsNone or array or tuple of arrays: If not None, then the weights assigned to each data point. If more than one data component is provided, you must provide a weights array for each data component (if not None).

Returns:

blocked_coordinatestuple of arrays: Tuple containing arrays with the coordinates of each block that contains data. If drop_coords is True, the tuple will only contain (easting, northing). If drop_coords is False, it will contain (easting, northing, vertical, …).
blocked_dataarray: The block reduced data values.

BlockReduce.get_metadata_routing()#

Get metadata routing of this object.

Please check User Guide on how the routing mechanism works.

Returns:

routingMetadataRequest: A MetadataRequest encapsulating routing information.

BlockReduce.get_params(deep=True)#

Get parameters for this estimator.

Parameters:

deepbool, default=True: If True, will return the parameters for this estimator and contained subobjects that are estimators.

Returns:

paramsdict: Parameter names mapped to their values.

BlockReduce.set_params(**params)#

Set the parameters of this estimator.

The method works on simple estimators as well as on nested objects (such as Pipeline). The latter have parameters of the form <component>__<parameter> so that it’s possible to update each component of a nested object.

Parameters:

**paramsdict: Estimator parameters.

Returns:

selfestimator instance: Estimator instance.

Examples using `verde.BlockReduce`#

Blocked reduction operations

Using weights in blocked reduction

Using weights in blocked means

Gridding with a cubic interpolator

Gridding with a linear interpolator

Projection of gridded data

Gridding with splines

Gridding with splines and weights

Gridding 2D vectors

Chaining Operations

Data Decimation

Geographic Coordinates

Vector Data

Using Weights

`filter`(coordinates, data[, weights])	Apply the blocked aggregation to the given data.
`get_metadata_routing`()	Get metadata routing of this object.
`get_params`([deep])	Get parameters for this estimator.
`set_params`(**params)	Set the parameters of this estimator.

verde.BlockReduce

Contents

verde.BlockReduce#

Methods#

Examples using verde.BlockReduce#

Examples using `verde.BlockReduce`#