gnome.spills

Subpackages

Submodules

Package Contents

Classes

Spill

Models a spill by combining Release and Substance objects

Release

base class for Release classes.

PointLineRelease

The primary spill source class -- a release of floating

PolygonRelease

A release of elements into a set of provided polygons.

VerticalPlumeRelease

An Underwater Plume spill class -- a continuous release of particles,

InitElemsFromFile

release object that sets the initial state of particles from a previously

NonWeatheringSubstance

A class for assigning a unique ID for an object

GnomeOil

Class to create an oil for use in Gnome

LEData

A MutableMapping is a generic container for associating

Functions

surface_point_line_spill(num_elements, start_position, ...)

Helper function returns a Spill object

subsurface_spill(num_elements, start_position, ...[, ...])

Helper function returns a Spill object

grid_spill(bounds, resolution, release_time[, ...])

Helper function returns a Grid Spill object

spatial_release_spill(start_positions, release_time[, ...])

Helper function returns a Spill object containing a spatial release

polygon_release_spill(filename[, release_time, ...])

Helper function returns a Spill object containing a polygon release

GridRelease(release_time, bounds, resolution)

Utility function that creates a release with a grid of elements.
class gnome.spills.Spill(on=True, num_elements=1000, amount=0, units='kg', substance=None, release=None, water=None, amount_uncertainty_scale=0.0, **kwargs)

Bases: BaseSpill

Models a spill by combining Release and Substance objects

Spills used by the gnome model. It contains a release object, which releases elements. It also contains a Substance which contains the type of substance spilled and it initializes data arrays to non-default values (non-zero).

Parameters:

  • release (derived from Release) – an object defining how elements are to be released

  • substance (derived from Substance) – an object defining the substance of this spill. Defaults to NonWeatheringSubstance

Optional parameters (kwargs):

Parameters:

  • name (str) – Human-usable Name of this spill

  • on=True – Toggles the spill on/off.

  • amount=None – mass or volume of oil spilled.

  • units=None – must provide units for amount spilled.

  • amount_uncertainty_scale=0.0 – scale value in range 0-1 that adds uncertainty to the spill amount. Maximum uncertainty scale is (2/3) * spill_amount.

Note

Define either volume or mass in ‘amount’ attribute and provide appropriate ‘units’.

property all_array_types

Need to add array types from Release and Substance

property substance
property release_time
property end_release_time
property release_duration
property num_elements
property start_position
property end_position
property amount
property units

Default units in which amount of oil spilled was entered by user. The ‘amount’ property is returned in these ‘units’

_schema
valid_vol_units
valid_mass_units
__repr__()

Return repr(self).

_check_units(units)

Checks the user provided units are in list of valid volume or mass units

get_mass()

Return the total mass released during the spill.

uncertain_copy()

Returns a deepcopy of this spill for the uncertainty runs

The copy has everything the same, including the spill_num, but it is a new object with a new id.

Not much to this method, but it could be overridden to do something fancier in the future or a subclass.

There are a number of python objects that cannot be deepcopied. - Logger objects

So we copy them temporarily to local variables before we deepcopy our Spill object.

set_amount_uncertainty(up_or_down=None)

This function shifts the spill amount based on a scale value in the range [0.0 … 1.0]. The maximum uncertainty scale value is (2/3) * spill_amount. We determine either an upper uncertainty or a lower uncertainty multiplier. Then we shift our spill amount value based on it.

Since we are irreversibly changing the spill amount value, we should probably do this only once.

rewind()

rewinds the release to original status (before anything has been released).

prepare_for_model_run(timestep)

array_types comes from all the other objects above in the model such as movers, weatherers, etc. The ones from the substance still need to be added

release_elements(sc, start_time, end_time, environment=None)

Releases and partially initializes new LEs Note: this will have to be updated if we allow backwards runs for continuous spills

num_elements_to_release(current_time, time_step)

Determines the number of elements to be released during: current_time + time_step

It invokes the num_elements_to_release method for the the underlying release object: self.release.num_elements_to_release()

Parameters:

  • current_time (datetime.datetime) – current time

  • time_step (int) – the time step, sometimes used to decide how many should get released.

Returns:

the number of elements that will be released. This is taken by SpillContainer to initialize all data_arrays.

_attach_default_refs(ref_dict)

!!!IMPORTANT!!! If this object requires default references (self._req_refs exists), this function will use the name of the references as keys into a reference dictionary to get a list of satisfactory references (objects that have obj._ref_as == self._req_refs). It will then attach the first object in the reference list to that attribute on this object.

This behavior can be overridden if the object needs more specific attachment behavior than simply ‘first in line’

In addition, this function SHOULD BE EXTENDED if this object should provide default references to any contained child objects. When doing so, please be careful to respect already existing references. The reference attachment system should only act if the requested reference ‘is None’ when the function is invoked. See Model._attach_default_refs() for an example.

gnome.spills.surface_point_line_spill(num_elements, start_position, release_time, end_position=None, end_release_time=None, substance=None, amount=0, units='kg', water=None, on=True, windage_range=None, windage_persist=None, name='Surface Point or Line Release')

Helper function returns a Spill object

Parameters:

  • num_elements (integer) – total number of elements to be released

  • start_position (2-tuple of floats (long, lat)) – initial location the elements are released

  • release_time (datetime.datetime) – time the LEs are released (datetime object)

  • end_position=None – Optional. For moving source, the end position If None, then release is from a point source

  • end_release_time=None – optional – for a time varying release, the end release time. If None, then release is instantaneous

  • substance=None – Type of oil spilled.

  • amount=None – mass or volume of oil spilled

  • units=None – units for amount spilled

  • .04) (tuple windage_range=(.01,) – Percentage range for windage. Active only for surface particles when a mind mover is added

  • windage_persist=900 – Persistence for windage values in seconds. Use -1 for inifinite, otherwise it is randomly reset on this time scale

  • Spill' (name='Surface Point/Line) – a name for the spill

gnome.spills.subsurface_spill(num_elements, start_position, release_time, distribution, distribution_type='droplet_size', end_release_time=None, substance=None, amount=0, units='kg', water=None, on=True, windage_range=None, windage_persist=None, name='Subsurface plume')

Helper function returns a Spill object

Parameters:

  • num_elements (integer) – total number of elements to be released

  • start_position (3-tuple of floats (long, lat, z)) – initial location the elements are released

  • release_time (datetime.datetime) – time the LEs are released (datetime object)

  • distribution=None – An object capable of generating a probability distribution. Right now, we have: * UniformDistribution * NormalDistribution * LogNormalDistribution * WeibullDistribution

  • distribution_type=droplet_size (str) – What is being sampled from the distribution. Options are: * droplet_size - Rise velocity is then calculated * rise_velocity - No droplet size is computed

  • end_release_time=None – End release time for a time varying release. If None, then release is instantaneous

  • substance=None – Required unless density specified. Type of oil spilled.

  • density=None (float) – Required unless substance specified. Density of spilled material.

  • density_units='kg/m^3' (str) –

  • amount=None (float) – mass or volume of oil spilled.

  • units=None (str) – must provide units for amount spilled.

  • .04) (tuple windage_range=(.01,) – Percentage range for windage. Active only for surface particles when a mind mover is added

  • windage_persist=900 – Persistence for windage values in seconds. Use -1 for inifinite, otherwise it is randomly reset on this time scale.

  • Release' (str name='Subsurface) – a name for the spill.

gnome.spills.grid_spill(bounds, resolution, release_time, substance=None, amount=1.0, units='kg', on=True, water=None, windage_range=None, windage_persist=None, name='Surface Grid Spill')

Helper function returns a Grid Spill object

Parameters:

  • bounds (2x2 numpy array or equivalent) – bounding box of region you want the elements in: ((min_lon, min_lat), (max_lon, max_lat))

  • resolution (integer) – resolution of grid – it will be a resoluiton X resolution grid

  • substance=None – Type of oil spilled.

  • amount=None (float) – mass or volume of oil spilled

  • units=None (str) – units for amount spilled

  • release_time (datetime.datetime) – time the LEs are released (datetime object)

  • .04) (tuple windage_range=(.01,) – Percentage range for windage. Active only for surface particles when a mind mover is added

  • windage_persist=900 (int) – Persistence for windage values in seconds. Use -1 for inifinite, otherwise it is randomly reset on this time scale

  • Release' (str name='Surface Point/Line) – a name for the spill

gnome.spills.spatial_release_spill(start_positions, release_time, substance=None, water=None, on=True, amount=0, units='kg', windage_range=None, windage_persist=None, name='spatial_release')

Helper function returns a Spill object containing a spatial release

A spatial release is a spill that releases elements at known locations.

gnome.spills.polygon_release_spill(filename, release_time=None, substance=None, water=None, on=True, amount=0, units='kg', windage_range=None, windage_persist=None, name='spatial_release')

Helper function returns a Spill object containing a polygon release

A polygon release is a spill that releases elements randomly within polygons in a shapefile.

class gnome.spills.Release(release_time=None, num_elements=None, num_per_timestep=None, end_release_time=None, custom_positions=None, release_mass=0, retain_initial_positions=False, **kwargs)

Bases: gnome.gnomeobject.GnomeId

base class for Release classes.

It contains interface for Release objects

Required Arguments:

Parameters:

  • release_time (datetime.datetime or iso string.) – time the LEs are released

  • custom_positions (iterable of (lon, lat, z)) – initial location(s) the elements are released

Optional arguments:

Note

Either num_elements or num_per_timestep must be given. If both are None, then it defaults to num_elements=1000. If both are given a TypeError is raised because user can only specify one or the other, not both.

Parameters:

  • num_elements (integer) – total number of elements to be released

  • num_per_timestep – fixed number of LEs released at each timestep

  • end_release_time=None – optional – for a time varying release, the end release time. If None, then release is instantaneous

  • release_mass=0 – optional. This is the mass released in kilograms.

  • retain_initial_positions (boolean) – Optional. If True, each LE will retain information about it’s originally released position

property centroid
property release_mass
property num_per_timestep
property num_elements
property release_duration

duration over which particles are released in seconds

property end_release_time
_schema
__repr__()

Return repr(self).

rewind()
LE_timestep_ratio(ts)

Returns the ratio

maximum_mass_error(ts)

This function returns the maximum error in mass present in the model at any given time. In theory, this should be the mass of 1 LE

get_num_release_time_steps(ts)

calculates how many time steps it takes to complete the release duration

generate_release_timeseries(num_ts, max_release, ts)

Release timeseries describe release behavior as a function of time. _release_ts describes the number of LEs that should exist at time T PolygonRelease does not have a _pos_ts because it uses start_positions only All use TimeseriesData objects.

num_elements_after_time(current_time)

Returns the number of elements expected to exist at current_time. Returns 0 if prepare_for_model_run has not been called. :param current_time: time of release :type current_time: datetime

prepare_for_model_run(ts)
Parameters:

ts – timestep as integer seconds

initialize_LEs(to_rel, sc, start_time, end_time)

set positions for new elements added by the SpillContainer

Note

this releases all the elements at their initial positions at the end_time

initialize_LEs_post_substance(to_rel, sc, start_time, end_time, environment)
class gnome.spills.PointLineRelease(release_time=None, start_position=None, num_elements=None, num_per_timestep=None, end_release_time=None, end_position=None, release_mass=0, **kwargs)

Bases: Release

The primary spill source class – a release of floating non-weathering particles, can be instantaneous or continuous, and be released at a single point, or over a line.

Required Arguments:

Parameters:

  • release_time (datetime.datetime) – time the LEs are released (datetime object)

  • start_position (3-tuple of floats (long, lat, z)) – initial location the elements are released

Optional arguments:

Note

Either num_elements or num_per_timestep must be given. If both are None, then it defaults to num_elements=1000. If both are given a TypeError is raised because user can only specify one or the other, not both.

Parameters:

  • num_elements (integer) – total number of elements to be released

  • num_per_timestep – fixed number of LEs released at each timestep

  • end_release_time=None – optional – for a time varying release, the end release time. If None, then release is instantaneous

  • end_position=None – optional. For moving source, the end position If None, then release from a point source

  • release_mass=0 – optional. This is the mass released in kilograms.

property is_pointsource

if end_position - start_position == 0, point source otherwise it is a line source

Returns:

True if point source, false otherwise

property centroid
property start_position
property end_position
_schema
__repr__()

Return repr(self).

generate_release_timeseries(num_ts, max_release, ts)

Release timeseries describe release behavior as a function of time. _release_ts describes the number of LEs that should exist at time T _pos_ts describes the spill position at time T All use TimeseriesData objects.

rewind()
prepare_for_model_run(ts)
Parameters:

ts – timestep as integer seconds

initialize_LEs(to_rel, sc, start_time, end_time)

Initializes the mass and position for to_rel new LEs. :param data: spill container with data arrays :param to_rel: number of elements to initialize :param start_time: initial time of release :param end_time: final time of release

initialize_LEs_post_substance(to_rel, sc, start_time, end_time, environment)
class gnome.spills.PolygonRelease(filename=None, features=None, polygons=None, weights=None, thicknesses=None, **kwargs)

Bases: Release

A release of elements into a set of provided polygons.

When X particles are determined to be released, they are into the polygons randomly. For each LE, pick a polygon, weighted by it’s proportional area and place the LE randomly within it. By default the PolygonRelease uses simple area for polygon weighting. Other classes (NESDISRelease for example) may use other weighting functions.

Required Arguments:

Parameters:

  • release_time (datetime.datetime) – time the LEs are released (datetime object)

  • polygons (list of shapely.Polygon or shapely.MultiPolygon.) – polygons to use in this release

Optional arguments:

Parameters:

  • filename (string name of a zip file. Polygons loaded are concatenated after polygons from kwarg) – (optional) shapefile

  • weights – (optional) LE placement probability weighting for each polygon. Must be the same length as the polygons kwarg, and must sum to 1. If None, weights are generated at runtime based on area proportion.

  • num_elements (integer) – total number of elements to be released

  • num_per_timestep – fixed number of LEs released at each timestep

  • end_release_time=None – optional – for a time varying release, the end release time. If None, then release is instantaneous

  • release_mass=0 – optional. This is the mass released in kilograms.

property filename
property centroid
property __geo_interface__
property features
property polygons
property thicknesses
property weights
property areas
_schema
gen_fc_from_kwargs(kwargs)
rewind()
get_polys_as_tris(polys, weights=None)
compute_distribution()
prepare_for_model_run(ts)
Parameters:

ts – timestep as integer seconds

initialize_LEs(to_rel, data, start_time, end_time)

set positions for new elements added by the SpillContainer

Note

this releases all the elements at their initial positions at the end_time

get_polygons()

Returns an array of lengths, and a list of line arrays. The first array sequentially indexes the second array. When the second array is split up using the first array and the resulting lines are drawn, you should end up with a picture of the polygons.

get_metadata()
classmethod new_from_dict(dict_)

creates a new object from dictionary

This is base implementation and can be over-ridden by classes using this mixin

gnome.spills.GridRelease(release_time, bounds, resolution)

Utility function that creates a release with a grid of elements.

Only 2-d for now

Parameters:

  • bounds (2x2 numpy array or equivalent) –

    bounding box of region you want the elements in: ((min_lon, min_lat),

    (max_lon, max_lat))

  • resolution (integer) – resolution of grid – it will be a resolution X resolution grid

class gnome.spills.VerticalPlumeRelease(release_time=None, start_position=None, plume_data=None, end_release_time=None, **kwargs)

Bases: Release

An Underwater Plume spill class – a continuous release of particles, controlled by a contained spill generator object. - plume model generator will have an iteration method. This will provide flexible looping and list comprehension behavior.

Parameters:

  • num_elements (integer) – total number of elements to be released

  • start_position (3-tuple of floats (long, lat, z)) – initial location the elements are released

  • release_time (datetime.datetime) – time the LEs are released

  • start_positions ((num_elements, 3) numpy array of float64 -- (long, lat, z)) – locations the LEs are released

_plume_elem_coords(current_time, time_step)

Return a list of positions for all elements released within current_time + time_step

num_elements_to_release(current_time, time_step)

Return number of particles released in current_time + time_step

set_newparticle_positions(num_new_particles, current_time, time_step, data_arrays)

Set positions for new elements added by the SpillContainer

class gnome.spills.InitElemsFromFile(filename, release_time=None, index=None, time=None)

Bases: Release

release object that sets the initial state of particles from a previously output NetCDF file

Take a NetCDF file, which is an output of PyGnome’s outputter: NetCDFOutput, and use these dataarrays as initial condition for the release. The release sets not only ‘positions’ but also all other arrays it finds. Arrays found in NetCDF file but not in the SpillContainer are ignored. Optional arguments, index and time can be used to initialize the release from any other record in the NetCDF file. Default behavior is to use the last record in the NetCDF to initialize the release elements.

Parameters:

filename (str) – NetCDF file from which to initialize released elements

Optional arguments:

Parameters:

  • index=None (int) – index of the record from which to initialize the release elements. Default is to use -1 if neither time nor index is specified

  • time (datetime) – timestamp at which the data is desired. Looks in the netcdf data’s ‘time’ array and finds the closest time to this and use this data. If both ‘time’ and ‘index’ are None, use data for index = -1

_read_data_file(filename, index, time)
num_elements_to_release(current_time, time_step)

all elements should be released in the first timestep unless start time is invalid. Start time is invalid if it is after the Spill’s releasetime

_set_data_arrays(num_new_particles, current_time, time_step, data_arrays)

Will set positions and all other data arrays if data for them was found in the NetCDF initialization file.

class gnome.spills.NonWeatheringSubstance(windage_range=None, windage_persist=None, standard_density=1000.0, *args, **kwargs)

Bases: Substance

A class for assigning a unique ID for an object

Parameters:

  • windage_range (tuple of values between 0 and 1) – Range of windages for the substance (leeway). Default: (.01, .04)

  • windage_persist=900 – persistence of windage settings in seconds. -1 or Inf means infinite.

  • standard_density=1000.0 – The density of the substance, used to convert mass to/from volume

property is_weatherable
_schema

The simplest substance that can be used with the model

It can not be weathered, but does have basic properties for transport:

Windage, density, etc.

initialize_LEs(to_rel, arrs, environment=None)

:param to_rel - number of new LEs to initialize :param arrs - dict-like of data arrays representing LEs

class gnome.spills.GnomeOil(oil_name=None, filename=None, water=None, **kwargs)

Bases: gnome.spills.substance.Substance

Class to create an oil for use in Gnome

Initialize a GnomeOil:

Parameters:

  • oil_name=None – Name of one of the sample oils provided by: gnome.spills.sample_oils

  • filename=None – filename (Path) of JSON file in the Adios Oil Database format.

  • water=None – Water object with environmental conditions – Deprecated.

Additional keyword arguments will be passed to Substance: e.g.: windage_range, windage_persist=None,

A GnomeOil can be initialized in three ways:

  1. From a sample oil name : GnomeOil(oil_name="sample_oil_name") the oils are available in gnome.spills.sample_oils

  2. From a JSON file in the ADIOS Oil Database format: GnomeOil(filename="adios_oil.json") usually records from the ADIOS Oil Database (https://adios.orr.noaa.gov)

  3. From the json : GnomeOil.new_from_dict(**json_) for loading save files, etc. (this is usually done under the hood)

GnomeOil(“sample_oil_name”) —works for test oils from sample_oils only

GnomeOil(oil_name=”sample_oil_name”)

GnomeOil(filename=”oil.json”) —load from file using adios_db

GnomeOil.new_from_dict(**json_) —webgnomeclient, savefiles, etc.

GnomeOil(“invalid_name”) —ValueError (not in sample oils)

property standard_density

Standard density is simply the density at 15C, which is the default temperature for density_at_temp()

_schema
_req_refs = ['water']
from_adiosdb_file(filename, kwargs)
_set_up_array_types()
_init_from_json(*, api, pour_point, solubility, bullwinkle_fraction, original_bullwinkle_fraction=None, bullwinkle_time=None, original_bullwinkle_time=None, emulsion_water_fraction_max, densities, density_ref_temps, density_weathering, kvis, kvis_ref_temps, kvis_weathering, mass_fraction, boiling_point, molecular_weight, component_density, sara_type=None, adios_oil_id=None, k0y=None, num_components=None, **kwargs)
__hash__()

needs to be hashable, so that it can be used in lru-cache

Oils will only hash equal if they are the same object – that’s limiting, but OK.

__deepcopy__(memo)
classmethod get_GnomeOil(oil_info, max_cuts=None)

#fixme: what is oil_info ???

Use this instead of get_oil_props

to_dict(json_=None)

Returns a dictionary representation of this object. Uses the schema to determine which attributes are put into the dictionary. No extra processing is done to each attribute. They are presented as is.

The json_ parameter is ignored in this base class. ‘save’ is passed in when the schema is saving the object. This allows an override of this function to do any custom stuff necessary to prepare for saving.

initialize_LEs(to_rel, arrs, environment=None)

:param to_rel - number of new LEs to initialize :param arrs - dict-like of data arrays representing LEs

fixme:

this shouldn’t use water temp – it should use standard density and STP temp – and let weathering_data set it correctly

Note

weathering data is currently broken for initial setting

_set_pc_values(prop, values)

utility that sets a property to each pseudo component

checks that it’s the right size, and converts to an array

vapor_pressure(temp, atmos_pressure=101325.0)

the vapor pressure on the PCs at a given temperature water_temp and boiling point units are Kelvin

Parameters:

temp – temperature in K

Returns:

vapor_pressure array in SI units (Pascals)

## Fixme: shouldn’t this be in the Evaporation code?

classmethod bounding_temperatures(obj_list, temperature)

General Utility Function

From a list of objects containing a ref_temp_k attribute, return the object(s) that are closest to the specified temperature(s)

Specifically:

  • We want the ones that immediately bound our temperature.

  • If our temperature is high and out of bounds of the temperatures in our obj_list, then we return a range containing only the highest temperature.

  • If our temperature is low and out of bounds of the temperatures in our obj_list, then we return a range containing only the lowest temperature.

We accept only a scalar temperature or a sequence of temperatures

get_densities()

return a list of densities for the oil at a specified state of weathering.

#fixme: this should not happen here!

We include the API as a density if:

  • the specified weathering is 0

  • the culled list of densities does not contain a measurement at 15C

density_at_temp(temperature=288.15)

Get the oil density at a temperature or temperatures.

Note

This is all kruft left over from the estimating code. At this point, a GnomeOil should already have what it needs.

Note

There is a catch-22 which prevents us from getting the min_temp in some cases:

  • To estimate pour point, we need viscosities

  • If we need to convert dynamic viscosities to kinematic, we need density at 15C

  • To estimate density at temp, we need to estimate pour point

  • …and then we recurse

For this case we need to make an exception.

Note

If we have a pour point that is higher than one or more of our reference temperatures, then the lowest reference temperature will become our minimum temperature.

TODO:

We are getting rid of the argument that specifies a weathering amount because it is currently implemented in an unusably precise manner. Robert would like us to implement a means of interpolating density using a combination of (temperature, weathering). But the algorithm for this is not defined at the moment.

_get_reference_densities(densities, temperature)

Given a temperature, we return the best measured density, and its reference temperature, to be used in calculation.

For our purposes, it is the density closest to the given temperature.

_vol_expansion_coeff(densities, temperature)
classmethod closest_to_temperature(obj_list, temperature, num=1)

General Utility Function

From a list of objects containing a ref_temp_k attribute, return the object(s) that are closest to the specified temperature(s)

We accept only a scalar temperature or a sequence of temperatures

kvis_at_temp(temp_k=288.15, weathering=0.0)

Compute the kinematic viscosity of the oil as a function of temperature

Parameters:

  • temp_k – temperatures to compute at: can be scalar or array of values. should be in Kelvin

  • weathering – fraction weathered – currently not implemented

viscosity as a function of temp is given by: v = A exp(k_v2 / T)

with constants determined from measured data

determine_visc_constants()

viscosity as a function of temp is given by:

v = A exp(k_v2 / T)

The constants, A and k_v2 are determined from the viscosity data:

If only one data point, a default value for k_vs is used:

2100 K, based on analysis of data in the ADIOS database as of 2018

If two data points, the two constants are directly computed

If three or more, the constants are computed by a least squares fit.

get(prop)

get oil props

class gnome.spills.LEData(name=None, *args, **kwargs)

Bases: collections.abc.MutableMapping, gnome.gnomeobject.AddLogger, dict

A MutableMapping is a generic container for associating key/value pairs.

This class provides concrete generic implementations of all methods except for __getitem__, __setitem__, __delitem__, __iter__, and __len__.

Initialize self. See help(type(self)) for accurate signature.

property num_released

The number of elements currently in the SpillContainer

If SpillContainer is initialized, all data_arrays exist as ndarrays even if no elements are released. So this will always return a valid int >= 0.

clear
__str__
rewind()
__eq__(other)

Compare equality of two LEData objects

__ne__(other)

Return self!=value.

__len__()

The “length” of a spill container is the number of elements in it. The first dimension of any ndarray in our data_arrays will always be the number of elements that are contained in a SpillContainer.

__getitem__(key)

x.__getitem__(y) <==> x[y]

__setitem__(key, value)

Set self[key] to value.

_set_existing_LEData(key, value)
__delitem__(key)

Delete self[key].

__iter__()

Implement iter(self).

__repr__()

Return repr(self).

prepare_for_model_run(array_types, substance)
initialize_data_arrays()

initialize_data_arrays() is called without input data during rewind and prepare_for_model_run to prepare the buffers and define the data arrays.

extend_data_arrays(num_new_elements)

Adds num_new_elements to the data arrays. Resizes the arrays as necessary. Data arrays are set to their initial_values

Parameters:

num_new_elements (int) – number of particles released