alchemist/it.unibo.alchemist.model.biochemistry/EnvironmentSupportingDeformableCells

EnvironmentSupportingDeformableCells

interface EnvironmentSupportingDeformableCells<P : Position<out P>?> : Environment<T, P>

Environment supporting deformable cells.

Parameters

<P>

position type

Inheritors

BioRect2DEnvironmentNoOverlap

Functions

addGlobalReaction

abstract fun addGlobalReaction(reaction: GlobalReaction<T>)

Add a GlobalReaction to the Environment.

addLayer

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

Add a Layer to the Environment.

addNode

abstract fun addNode(node: Node<T>, position: P): Boolean

Adds a new node to this environment in a specific position. The environment is responsible for calling the right method of the simulation to ensure that the reaction is properly scheduled. The function returns true if the node is added to the environment.

addTerminator

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

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

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.

allSubNetworks

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>>

forEach

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

getDimensions

abstract fun getDimensions(): Int

The number of dimensions of this environment.

getDistanceBetweenNodes

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

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

getGlobalReactions

abstract fun getGlobalReactions(): NonExistentClass

Get the Environment's GlobalReactions.

getIncarnation

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

Return the Incarnation used to initialize the entities of this Environment, if it has been set.

getLayer

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

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

getLayers

abstract fun getLayers(): NonExistentClass

Return all the Layers in this Environment.

getLinkingRule

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

Returns the current LinkingRule.

getMaxDiameterAmongCircularDeformableCells

abstract fun getMaxDiameterAmongCircularDeformableCells(): Double

getNeighborhood

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

Given a node, this method returns its neighborhood.

getNodeByID

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

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

getNodeCount

abstract fun getNodeCount(): Int

Returns the number of Nodes currently in the Environment.

getNodes

abstract fun getNodes(): NonExistentClass

Returns all the Nodes that exist in current Environment.

getNodesWithinRange

abstract fun getNodesWithinRange(node: Node<T>, range: Double): NonExistentClass

Given a node this method returns a list of all the surrounding 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.

getOffset

abstract fun getOffset(): Array<Double>

This method allows to know which are the smallest coordinates represented. Return an array of length dimensions containing the smallest coordinates for each dimension.

getPosition

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

Calculates the position of a node.

getSimulation

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

Return the current Simulation, if present, or throws an IllegalStateException otherwise.

getSimulationOrNull

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

Return the current Simulation, if present, or null otherwise.

getSize

abstract fun getSize(): Array<Double>

The size of the environment as an array of length getDimensions(). This method must return distance measured with the same unit used by the positions. No non-euclidean distance metrics are allowed.

getSizeInDistanceUnits

abstract fun getSizeInDistanceUnits(): Array<Double>

This method returns the size of the environment as an array of length .getDimensions. This method must return distance measured with the same unit used for measuring distances. It may or may not return the same result of .getSize.

isNetworkSegmented

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

Returns true the network is segmented, false otherwise.

isTerminated

abstract fun isTerminated(): Boolean

Return true if all the terminators are true.

iterator

abstract fun iterator(): Iterator<T>

makePosition

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

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

moveNodeToPosition

abstract fun moveNodeToPosition(node: Node<T>, position: P)

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

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.

randomElement

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

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

removeGlobalReaction

abstract fun removeGlobalReaction(reaction: GlobalReaction<T>)

Remove a GlobalReaction from the Environment.

removeNode

abstract fun removeNode(node: Node<T>)

Removes node. If node removal is unsupported, it does nothing.

setLinkingRule

abstract fun setLinkingRule(<set-?>: LinkingRule<T, P>)

Returns the current LinkingRule.

setSimulation

abstract fun setSimulation(<set-?>: Simulation<T, P>)

Return the current Simulation, if present, or throws an IllegalStateException otherwise.

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

open fun spliterator(): Spliterator<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.