39.0.0

alchemist-implementationbase/it.unibo.alchemist.model.environments/Abstract2DEnvironment

Abstract2DEnvironment

abstract class Abstract2DEnvironment<T, P : Position2D<P>?> : AbstractEnvironment<T, P> (source)

Models a bidimensional environment.

Parameters

<T>

concentration type

<P>

Position2D type

Properties

globalReactions

val globalReactions: ListSet<GlobalReaction<T>>

open val incarnation: Incarnation<T, P>

open var linkingRule: LinkingRule<T, P>

val nodes: ListSet<Node<T>>

@Nullable

open var simulation: Simulation<T, P>

Functions

addGlobalReaction

abstract fun addGlobalReaction(p: GlobalReaction<T>)

open fun addGlobalReaction(@Nonnull reaction: GlobalReaction<T>)

abstract fun addLayer(p: Molecule, p1: Layer<T, P>)

fun addLayer(@Nonnull molecule: Molecule, @Nonnull layer: Layer<T, P>)

abstract fun addNode(p: Node<T>, p1: P): Boolean

fun addNode(@Nonnull node: Node<T>, @Nonnull p: P): Boolean

abstract fun addTerminator(p: TerminationPredicate<T, P>)

open fun addTerminator(@NotNull terminator: TerminationPredicate<T, P>)

Adds to the simulation a predicate that determines whether a simulation should be terminated.

allShortestHopPaths

fun <T> Environment<T, *>.allShortestHopPaths(): Map<Environments.UndirectedEdge<T>, Double>

Calculates the shortest paths using the Floyd-Warshall algorithm calculating the Hop Distance between nodes.

allShortestPaths

fun <T> Environment<T, *>.allShortestPaths(computeDistance: (Node<T>, Node<T>) -> Double = neighborDistanceMetric { n1, n2 -> getDistanceBetweenNodes(n1, n2) }): Map<Environments.UndirectedEdge<T>, Double>

Computes all the minimum distances with the provided metric using the Floyd–Warshall algorithm.

fun <T> Environment<T, *>.allSubNetworks(computeDistance: (Node<T>, Node<T>) -> Double = environmentMetricDistance()): Set<Network<T>>

Computes the diameter of all subnetworks in the environment. The diameter is the longest shortest path between any two nodes. Returns a Set containing the SubNetworks.

allSubNetworksByNode

fun <T> Environment<T, *>.allSubNetworksByNode(computeDistance: (Node<T>, Node<T>) -> Double = environmentMetricDistance()): Map<Node<T>, Network<T>>

Computes the diameter of all subnetworks in the environment. The diameter is the longest shortest path between any two nodes. Returns a Set containing the SubNetworks.

allSubNetworksByNodeWithHopDistance

fun <T> Environment<T, *>.allSubNetworksByNodeWithHopDistance(): Map<Node<T>, Network<T>>

Computes the diameter of all subnetworks in the environment. The diameter is the longest shortest path between any two nodes, evaluated using the allShortestHopPaths method. Returns a Set containing the SubNetworks.

allSubNetworksWithHopDistance

fun <T> Environment<T, *>.allSubNetworksWithHopDistance(): Set<Network<T>>

Computes the diameter of all subnetworks in the environment. The diameter is the longest shortest path between any two nodes, evaluated using the allShortestHopPaths method. Returns a Set containing the SubNetworks.

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

open fun forEach(p: Consumer<in T>)

fun getDimensions(): Int

getDistanceBetweenNodes

abstract fun getDistanceBetweenNodes(p: Node<T>, p1: Node<T>): Double

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

getGlobalReactions

abstract fun getGlobalReactions(): ListSet<GlobalReaction<T>>

abstract fun getIncarnation(): Incarnation<T, P>

abstract fun getLayer(p: Molecule): Layer<T, P>

@Nullable

fun getLayer(@Nonnull molecule: Molecule): Layer<T, P>

abstract fun getLayers(): ListSet<Layer<T, P>>

fun getLayers(): ListSet<Layer<T, P>>

abstract fun getLinkingRule(): LinkingRule<T, P>

getNeighborhood

abstract fun getNeighborhood(p: Node<T>): Neighborhood<T>

fun getNeighborhood(@Nonnull node: Node<T>): Neighborhood<T>

abstract fun getNodeByID(p: Int): Node<T>

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

abstract fun getNodeCount(): Int

fun getNodeCount(): Int

abstract fun getNodes(): ListSet<Node<T>>

getNodesWithinRange

abstract fun getNodesWithinRange(p: Node<T>, p1: Double): ListSet<Node<T>>

fun getNodesWithinRange(@Nonnull position: P, range: Double): ListSet<Node<T>>

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

fun getOffset(): Array<Double>

abstract fun getPosition(p: Node<T>): P

fun getPosition(@Nonnull node: Node<T>): P

abstract fun getSimulation(): Simulation<T, P>

getSimulationOrNull

abstract fun getSimulationOrNull(): Simulation<T, P>

@Nullable

open fun getSimulationOrNull(): Simulation<T, P>

fun getSize(): Array<Double>

getSizeInDistanceUnits

abstract fun getSizeInDistanceUnits(): Array<Double>

open fun getSizeInDistanceUnits(): Array<Double>

Override this method if units measuring distance do not match with units used for coordinates.

isNetworkSegmented

fun <T> Environment<T, *>.isNetworkSegmented(): Boolean

Returns true the network is segmented, false otherwise.

abstract fun isTerminated(): Boolean

fun isTerminated(): Boolean

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

abstract fun iterator(): Iterator<T>

abstract fun makePosition(p: Array<Number>): P

moveNodeToPosition

open fun moveNodeToPosition(@Nonnull node: Node<T>, @Nonnull newpos: P)

Subclasses may override this method if they want to change the way a node moves towards some absolute position.

networkDiameter

fun Environment<*, *>.networkDiameter(): Double

Returns the diameter of the network in environment units if it is not segmented, and NaN otherwise.

networkDiameterByHopDistance

fun Environment<*, *>.networkDiameterByHopDistance(): Double

Returns the hop-distance diameter of the network if it is not segmented, and NaN otherwise.

fun <T> Environment<T, *>.networkDiameterByHopDistance(node: Node<T>): Double

Computes the network diameter of the segment containing node.

removeGlobalReaction

abstract fun removeGlobalReaction(p: GlobalReaction<T>)

open fun removeGlobalReaction(@Nonnull reaction: GlobalReaction<T>)

abstract fun removeNode(p: Node<T>)

fun removeNode(@Nonnull node: Node<T>)

abstract fun setLinkingRule(p: LinkingRule<T, P>)

abstract fun setSimulation(p: Simulation<T, P>)

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

open fun spliterator(): Spliterator<T>

open fun toString(): String

Not used internally.