lgca.nove_ib_base.NoVE_IBLGCA_base¶

class lgca.nove_ib_base.NoVE_IBLGCA_base(nodes=None, dims=None, density=0.1, restchannels=1, bc='periodic', seed=None, propagation=True, **kwargs)¶

Bases: NoVE_LGCA_base, IBLGCA_base, ABC

Base class for identity-based LGCA without volume exclusion.

add_family(ancestor_fam)¶

Create a new family and register it in the family tree.

Parameters:: ancestor_fam (int) – Family that the new one descends from.

Warning

Please do not call this unless you are writing an interaction function that deals with mutations.

It accesses self.maxfamily and self.family_props which do not exist if self.init_families() has not been called in the LGCA initialization.

apply_abc()¶

Apply absorbing boundary conditions.

Update self.nodes, using the shadow border nodes and respecting the geometry.

apply_inflowbc()¶

Apply inflow boundary conditions.

Update self.nodes, using the shadow border nodes and respecting the geometry.

apply_pbc()¶

Apply periodic boundary conditions.

Update self.nodes, using the shadow border nodes and respecting the geometry.

apply_rbc()¶

Apply reflecting boundary conditions.

Update self.nodes, using the shadow border nodes and respecting the geometry.

abstract property c: ndarray¶: (Class attribute.) Array of the velocity channel vectors. Dimensions: (dims, lgca.velocitychannels), where dims is 1 or 2 depending on the geometry.

calc_entropy(base=None)¶: Calculate entropy of the lattice. :type base: :param base: base of the logarithm, defaults to 2 :return: entropy according to information theory as scalar

calc_family_generations()¶

Calculate which generation each family belongs to, i.e. how many mutations have occurred. The list is returned and stored in self.family_props['generation'].

Returns:: Family generations indexed by family ID, helper root family = generation 0, families at the beginning of the simulation = generation 1.

calc_family_pop_alive()¶: Calculate how many cells of each family are alive. :returns: np.ndarray fam_pop_array - array of family population counts indexed by family ID

calc_flux(nodes)¶

Calculate the flux vector for all lattice sites in nodes.

The elements of the flux vectors are computed as the dot product between the LGCA’s neighborhood vectors and the velocity channel configuration in nodes.

Parameters:: nodes (numpy.ndarray) – Lattice configuration to compute the flux for. Must have more than or the same number of dimensions as self.nodes and nodes.shape[-1] >= self.velocitychannels. Is typically self.nodes.
Returns:: Array of flux vectors at each lattice site. Dimensions: nodes.shape[:-1] + (len(self.c),).

calc_generation_pop()¶

Calculate the current population per family generation.

Returns:: Cell numbers per generation, indexed by generation (helper root family is generation 0, families present at initialization are generation 1).

calc_generation_pop_t(cutoff_abs=None, cutoff_rel=None)¶

Calculate the population per family generation at each simulation step. Requires a previous self.timeevo() with recordfampop=True.

Parameters:

cutoff_abs (int) – Exclude families that never exceeded this population size in absolute numbers. cutoff_rel takes precedence over cutoff_abs.
cutoff_rel (float) – Exclude families that never exceeded this population size, expressed as a fraction of the total population. cutoff_rel takes precedence over cutoff_abs.

Returns:

Cell numbers per generation at each timestep (helper root family is generation 0, families present at initialization are generation 1). Dimensions: (timesteps+1, generations+1).

calc_init_families_pop()¶

Calculate the current population per family that was initialised in the beginning of the simulation (“initial ancestor”) and its descendants.

Returns:

init_families_pop (numpy.ndarray) – Population per initial family.
init_ancestor_IDs (numpy.ndarray) – Initial family ID corresponding to each position in init_families_pop.

calc_init_families_pop_t(cutoff_abs=None, cutoff_rel=None)¶

Calculate the current population per family that was initialised in the beginning of the simulation (“initial ancestor”) and its descendants at each simulation step. Requires a previous self.timeevo() with recordfampop=True.

Parameters:

cutoff_abs (int) – Exclude families that never exceeded this population size in absolute numbers. cutoff_rel takes precedence over cutoff_abs.
cutoff_rel (float) – Exclude families that never exceeded this population size, expressed as a fraction of the total population. cutoff_rel takes precedence over cutoff_abs.

Returns:

init_families_pop (numpy.ndarray) – Population per initial family at each timestep, dimensions: (timesteps+1, num_init_families+1).
init_ancestor_IDs (numpy.ndarray) – Family ID corresponding to each position on the family dimension in init_families_pop.

calc_mean_alignment()¶: Calculate the mean alignment measure. The mean alignment is a measure for local alignment of particle orientation in the lattice. It is calculated as the agreement in direction between the ﬂux of a lattice site and the ﬂux of the director field summed up and normalized over all lattice sites. .. note:: This is buggy! :return: Local alignment parameter: ranging from -1 (antiparallel alignment) through 0 (no alignment) to 1 (parallel alignment)

calc_normalized_entropy(base=None)¶: Calculate entropy of the lattice normalized to maximal possible entropy. :type base: :param base: base of the logarithm, defaults to 2 :return: normalized entropy as scalar

calc_permutations()¶: Initialize lazy computation structures for permutations. Only compute permutations when actually needed.

calc_polar_alignment_parameter()¶: Calculate the polar alignment parameter. The polar alignment parameter is a measure for global agreement of particle orientation in the lattice. It is calculated as the magnitude of the sum of the velocities of all particles normalized by the number of particles. :return: Polar alignment parameter of the lattice from 0 (no alignment) to 1 (complete alignment)

calc_prop_mean(nodes=None, props=None, propname=None)¶: Calculate the mean value of a property “propname” on every node, given the node configuration “nodes” and the properties “props”

calc_prop_mean_spatiotemp(nodes_t=None, props=None)¶: Given the lgca states nodes_t, calculate the mean of individual cell properties at each node for each time point. :type nodes_t: :param nodes_t: Recorded node states. If omitted, use recorded state of latest timeevo. :type props: :param props: dictionary of individual cell properties. If omitted, props dictionary of current instance is used :return:

static convert_bool_to_ib(conf)¶

Convert the booleans in the lattice configuration of a classical LGCA with volume exclusion into unique particle identifiers.

Parameters:: conf (numpy.ndarray) – Lattice configuration for a classical LGCA with volume exclusion.
Returns:: Node configuration of conf converted to an identity-based LGCA. Dimensions: conf.shape.

convert_int_to_ib(occ)¶: Convert an array of integers representing the occupation numbers of an lgca to an array consisting of lists of individual cell labels, starting at 0. The length of each list corresponds to the entry in ‘occ’. :type occ: :param occ: array of occupation numbers. must match the lgca dimensions :return: array, where each entry is a list of individual cell labels.

filter_family_population_t(fam_pop_t=None, cutoff_abs=None, cutoff_rel=None)¶

Mask out families from fam_pop_t that never exceeded the given population threshold.

Parameters:

cutoff_abs (int) – Exclude families that never exceeded this population size in absolute numbers. cutoff_rel takes precedence over cutoff_abs.
cutoff_rel (float) – Exclude families that never exceeded this population size, expressed as a fraction of the total population. cutoff_rel takes precedence over cutoff_abs.
fam_pop_t (numpy.ndarray, default=``self.fam_pop_t``) – Each family’s population size over time, dimensions: (timesteps + 1, num_families + 1).

Returns:

fam_pop_t with all population values for too small families set to 0, dimensions: (timesteps + 1, num_families + 1). Original fam_pop_t if both cutoff parameters are None.

get_flux_permutations(n_particles)¶: Get flux permutations for n_particles.

get_permutations(n_particles)¶

Get permutations for n_particles.

Parameters:: n_particles (int) – Number of occupied channels.
Returns:: Array of permutations for n_particles.

get_prop(nodes=None, props=None, propname=None)¶: Return array of property “propname” on every node, given the lattice configuration “nodes” and the property dictionary “props”.

abstractmethod gradient(qty)¶

Compute the gradient of qty along all axes.

Parameters:: qty (numpy.ndarray) – Quantity to take the gradient of. Needs to have the same number of dimensions as self.nodes. If qty.shape == self.nodes.shape[:-1] the result can be indexed with the LGCA coordinates (see example).
Returns:: Computed gradient. Dimensions: qty.shape + (len(self.c),). If self and qty are 2D arrays, gradient(qty)[...,0] is the gradient in x direction and gradient(qty)[...,1] the gradient in y direction.

Notes

The gradient is calculated using numpy.gradient() with stepwidth h=0.5 (s.t. no normalization takes place). It is computed as the central finite difference with equidistant support points and supports one-sided differences at the boundaries.

In most cases this yields the simple difference between the two closest array elements in the given direction. For example, the gradient at position 1 of np.array([1, 2, 4]) would be (4 - 1)/(2 * 0.5) = 3.

Examples

If the input quantity has the same x (and y) dimensions as the LGCA’s nodes, the gradient at each node position can be accessed the same way as the node itself.

>>> from lgca import get_lgca
>>> import numpy as np
>>> # define a square LGCA to illustrate dimensions
>>> lgca = get_lgca(geometry='square', dims=(2,3))
>>> lgca.nodes.shape  # (xdim, ydim, number of channels)
(4, 5, 4)
>>> my_qty = np.array([[0,0,0,0,0],
>>>                    [1,1,1,1,1],
>>>                    [2,2,2,3,2],
>>>                    [3,3,3,3,3]])
>>> my_qty.shape  # (xdim, ydim)
(4, 5)
>>> grad = lgca.gradient(my_qty)
>>> grad.shape  # (xdim, ydim, number of dimensions)
(4, 5, 2)
>>> # address like internal LGCA fields: first dimension is x (printed vertically),
>>> # second dimension is y (printed horizontally), this can be a bit confusing
>>> for coord in lgca.coord_pairs:
>>>     if np.any(grad[coord]>2):
>>>         print("Gradient at index", coord, "is ", grad[coord])
>>>         print("Configuration at index ", coord, " is ", lgca.nodes[coord],
>>>               ", with cell density ", lgca.cell_density[coord])
Gradient at index (1, 3) is  [3. 0.]
Configuration at index  (1, 3)  is  [False False False  True] , with cell density  1

The first element of the gradient holds the gradient in x direction, the second element the gradient in y direction. Note that (1, 3) is the index corresponding to a logical non-border coordinate (0, 2) if the interaction radius is 1. This is relevant for defining a custom field qty: Only the field values at non-border indices will be “felt” by the particles in the LGCA if the interaction is defined accordingly, but border nodes can be used to specify the field’s boundary conditions.

The gradient in x direction is 3 = (3 - 0)/1. In y direction it is 0 = (1 - 1)/1.

abstractmethod init_coords()¶

Initialize LGCA coordinates. These are used to index the lattice nodes. In the implementation, set self.nonborder, self.xcoords, self.ycoords, and self.coord_pairs to meaningful and consistent values.

Must match what is done in set_dims() and init_nodes(). For the attribute types see lgca.base.LGCA_base.

init_families(type='homogeneous', mutation=True)¶

Initialize structures to track inheritance between cells and/or cell families.

Initializes the 'family' property in self.props and, if needed, the counter self.maxfamily and the dictionary self.family_props. The 'ancestor' and 'descendants' properties in the latter can be used to reconstruct a family tree.

Parameters:

mutation (bool, default=True) – If true, mutation can occur so that offspring can have different properties and found its own family. The additional dictionary self.family_props and the counter self.maxfamily keep track of this. If false, the number of families is not supposed to increase during the simulation so that self.family_props and self.maxfamily are not needed.
type ({'homogeneous', 'heterogeneous'}, default='homogeneous') – Family composition for the initial population. If homogeneous, all initial cells belong to the same family and have the same properties. If heterogeneous, each initial cell founds its own family and can have individual properties that it passes on to its offspring.

biolgca

Navigation

Related Topics

lgca.nove_ib_base.NoVE_IBLGCA_base¶