opendrift.readers.basereader

Submodules

Attributes

`logger`
`standard_names`
`vector_pairs_xy`

Classes

`Variables`	Handles reading and interpolation of variables.
`Combine`	Combining two readers into a third one. You can use usual operators,
`Filter`
`ReaderBlock`	Class to store and interpolate the output from a reader with data on a regular (structured) grid.
`BaseReader`	An abstract reader. Implementors provide a method to read data and specify how it is interpolated.

Package Contents

opendrift.readers.basereader.logger

class opendrift.readers.basereader.Variables[source]

Bases: ReaderDomain

Handles reading and interpolation of variables.

variables = None

derived_variables = None

name = None

buffer = 0

environment_mappings

prepare(extent, start_time, end_time, max_speed)[source]: Prepare reader for given simulation coverage in time and space.

activate_environment_mapping(mapping_name)[source]

__calculate_derived_environment_variables__(env)[source]

set_buffer_size(max_speed, time_coverage=None)[source]

Adjust buffer to minimise data block size needed to cover elements.

The buffer size is calculated from the maximum anticpated speed. Seeding over a large area or over longer time can easily cause particles to be located outside the block. This is not critical, but causes interpolation to be one-sided in time for the relevant particles.

Args:

max_speed (m/s): the maximum speed anticipated for particles. time_coverage (timedelta): the time span to cover

__check_env_coordinates__(env)[source]: Make sure x and y are floats (and not e.g. int64)

static __check_variable_array__(name, variable)[source]: Ensure arrays are not masked arrays and that values are within valid ranges.

__check_env_arrays__(env)[source]: Ensure arrays are not masked arrays and that values are within valid ranges.

See also

Disabled in StructuredReader because variables are valided before entered into interpolator:

structured.StructuredReader.__check_env_arrays__()

abstractmethod _get_variables_interpolated_(variables, profiles, profiles_depth, time, reader_x, reader_y, z)[source]

This method _must_ be implemented by every reader. Usually by subclassing one of the reader types (e.g. structured.StructuredReader).

Arguments are in _native projection_ of reader.

get_variables_interpolated_xy(variables, profiles=None, profiles_depth=None, time=None, x=None, y=None, z=None, rotate_to_proj=None)[source]

Get variables in native projection of reader.

See also

get_variables_interpolated().
_get_variables_interpolated_().

get_variables_interpolated(variables, profiles=None, profiles_depth=None, time=None, lon=None, lat=None, z=None, rotate_to_proj=None)[source]

get_variables_interpolated is the main interface to opendrift.basemodel.OpenDriftSimulation, and is responsible for returning variables at the correct positions.

Readers should implement _get_variables_interpolated_().

Arguments:

variables: string, or list of strings (standard_name) of
requested variables. These must be provided by reader.

profiles: List of variable names that should be returned for the range in profiles_depth.

profiles_depth: Profiles variables will be retrieved from surface and down to this depth. The exact z-depth are given by the reader and returned as z variable in env_profiles.

time: datetime or None, time at which data are requested.
Can be None (default) if reader/variable has no time dimension (e.g. climatology or landmask).

lon: longitude, 1d array.

lat: latitude, 1d array, same length as lon.

z: float or ndarray; vertical position (in meters, positive up)
of requested points. either scalar or same length as lon, lat. default: 0 m (unless otherwise documented by reader)

block: bool, see return below

rotate_to_proj: N/A

Returns:

(env, env_profiles)

Interpolated variables at x, y and z. env contains values at a fixed depth (z), while env_profiles contains depth-profiles in the range profile_depth for the variables listed in profiles for each element (in x, y). The exact depth is determined by the reader and specified in env_profiles[‘z’]. Thus variables in env_profiles are not interpolated in z-direction.

See also

get_variables_interpolated_xy().

opendrift.readers.basereader.standard_names

opendrift.readers.basereader.vector_pairs_xy = [['x_wind', 'y_wind', 'wind_speed', 'wind_to_direction', 'wind_from_direction'],...

class opendrift.readers.basereader.Combine[source]

Combining two readers into a third one. You can use usual operators, but also more complex ones such as gaussian combining.

__add__(other)[source]

__radd__(other)[source]

__mul__(other)[source]

__rmul__(other)[source]

__truediv__(other)[source]

__sub__(other)[source]

combine_gaussian(measurement_reader, std)[source]: Mix two readers with a gaussian, whose std is the one given as an argument. The measurment reader have to be of type timeseries, with a lon and lat attributes that are taken as the center of the measure.

class opendrift.readers.basereader.Filter[source]

property variables: List[str]

Abstractmethod:
Return type:: List[str]

filter_vars(vars)[source]: Only keep the specified variables.

exclude_vars(vars)[source]: Remove the specified variables.

class opendrift.readers.basereader.ReaderBlock(data_dict, interpolation_horizontal='linearNDFast', interpolation_vertical='linear', wrap_x=False)[source]

Class to store and interpolate the output from a reader with data on a regular (structured) grid.

x

y

time

data_dict

wrap_x = False

_initialize_interpolator(x, y, z=None)[source]

interpolate(x, y, z=None, variables=None, profiles=[], profiles_depth=None)[source]

_interpolate_horizontal_layers(data, nearest=False)[source]: Interpolate all layers of 3d (or 2d) array.

_wrap_longitude(x)[source]

covers_positions(x, y, z=None)[source]: Check if given positions are covered by this reader block.

class opendrift.readers.basereader.BaseReader[source]

Bases: variables.Variables, opendrift.readers.operators.ops.Combine, opendrift.readers.operators.ops.Filter

An abstract reader. Implementors provide a method to read data and specify how it is interpolated.

This class inherits variables.Variables which inherits variables.ReaderDomain. ReaderDomain is responsible for the extent and domain of the reader, including checking for out-of-bounds and projection conversion. Variables is responsible for returning interpolated data at the requests positions or profiles. Apart from coercing the returned data into the right type for opendrift.models.basemodel, it defines the abstract interface to variables.Variables._get_variables_interpolated_() which reader-implementations must provide (_usually_ through one of the main reader-types, see: opendrift.readers).