This method allows to add a new node to this environment in a specific position. The environment is responsible to call the right method of the simulation in order to ensure that the reaction is properly scheduled. The function returns true if the node is added to the environment.

addTerminator

open fun addTerminator(terminator: (Environment<T, Euclidean2DPosition>) -> Boolean)

Add a terminator indicating whether the simulation should be considered finished.

open override fun addTerminator(terminator: TerminationPredicate<T, Euclidean2DPosition>)

Add a terminator indicating whether the simulation should be considered finished.

forEach

override fun forEach(action: Consumer<in Node<T>>)

getDistanceBetweenNodes

override fun getDistanceBetweenNodes(n1: Node<T>, n2: Node<T>): Double

Measures the distance between two nodes (n1, n2) in the environment.

getLayer

override fun getLayer(molecule: Molecule): Layer<T, Euclidean2DPosition>?

Get the Layer associate to the given molecule. If no Layer is associated with the given molecule, return null.

getNeighborhood

override fun getNeighborhood(node: Node<T>): Neighborhood<T>

Given a node, this method returns its neighborhood.

getNodeByID

override fun getNodeByID(id: Int): Node<T>

Allows to access a Node in this Environment known its id. Depending on the implementation, this method may or not be optimized (namely, id could run in constant or linear time with the number of nodes).

getNodesWithinRange

override fun getNodesWithinRange(node: Node<T>, range: Double): ListSet

Given a node this method returns a list of all the surroundings nodes within the given range. Note that this method (depending on the implementation) might be not optimized, and it's consequently much better to use Environment.getNeighborhood and filter the neighborhood if you are sure that all the nodes within the range are connected to the center.

override fun getNodesWithinRange(position: Euclidean2DPosition, range: Double): ListSet

Given a position this method returns a list of all the surroundings nodes within the given range. Note that this method (depending on the implementation) might be not optimized.

getPosition

override fun getPosition(node: Node<T>): Euclidean2DPosition

Calculates the position of a node.

iterator

operator override fun iterator(): Iterator<Node<T>>

makePosition

abstract fun makePosition(vararg coordinates: Number): Euclidean2DPosition

open fun makePosition(coordinates: List<Number>): Euclidean2DPosition

Given the coordinates of the point, returns a Position compatible with this environment.

open fun makePosition(x: Double, y: Double): Euclidean2DPosition

open fun makePosition(x: Number, y: Number): Euclidean2DPosition

Creates a new Euclidean2DPosition.

moveNode

open fun moveNode(node: Node<T>, direction: Euclidean2DPosition)

This method moves a node in the environment toward some direction. If node move is unsupported, it does nothing. Subclasses may override this method if they want to change the way a node moves towards some direction. The current implementation internally calls {@link #moveNodeToPosition(Node, Position2D)}, as such, overriding that method may suffice.

moveNodeToPosition

open override fun moveNodeToPosition(node: Node<T>, position: Euclidean2DPosition)

This method moves a node in the environment to some position. If node move is unsupported, it does nothing.

randomElement

fun <R> Iterable<R>.randomElement(randomGenerator: <Error class: unknown class>): R

Returns a random element of the Iterable using the provided randomGenerator.

removeGlobalReaction

open override fun removeGlobalReaction(reaction: GlobalReaction<T>)

Remove a GlobalReaction from the Environment.

removeNode

override fun removeNode(node: Node<T>)

This method allows to remove a node. If node removal is unsupported, it does nothing.

shuffled

fun <R> Iterable<R>.shuffled(randomGenerator: <Error class: unknown class>): Iterable<R>

Fisher–Yates shuffle algorithm using a RandomGenerator. More information on Wikipedia.

spliterator

override fun spliterator(): Spliterator<Node<T>>

subscriptionMonitor

fun <T, P : Position<out P>> Environment<T, P>.subscriptionMonitor(): EnvironmentSubscriptionMonitor<T, P>

Returns the EnvironmentSubscriptionMonitor of this Environment.

toEnvironmentSurrogate

fun <T, P : Position<out P>, TS : Any> Environment<T, P>.toEnvironmentSurrogate(toConcentrationSurrogate: (T) -> TS): EnvironmentSurrogate<TS, PositionSurrogate>

A function that maps an Environment to its surrogate class (EnvironmentSurrogate). Use the toSuitablePositionSurrogate strategy for PositionSurrogate mapping.

fun <T, P : Position<out P>, TS : Any, PS : PositionSurrogate> Environment<T, P>.toEnvironmentSurrogate(toConcentrationSurrogate: (T) -> TS, toPositionSurrogate: (P) -> PS): EnvironmentSurrogate<TS, PS>

A function that maps an Environment to its surrogate class (EnvironmentSurrogate).

toGraphQLEnvironmentSurrogate

fun <T, P : Position<out P>> Environment<T, P>.toGraphQLEnvironmentSurrogate(): EnvironmentSurrogate<T, P>

Converts an Environment to a EnvironmentSurrogate.

toString

open override fun toString(): String

Not used internally. Override as you please.