alchemist/it.unibo.alchemist.model.networks

Package-level declarations

Types

abstract class AccessPointNetworkModel<T, P : Position, Input>(environment: Environment<T, P>, radius: Double, val accessPointId: Molecule) : ObservingRangeBasedNetworkModel<T, P, Input>

An ObservingRangeBasedNetworkModel whose links depend on which nodes are access points, namely the nodes containing accessPointId.

AdaptiveRange

open class AdaptiveRange<T, P : Position> @JvmOverloads constructor(environment: Environment<T, P>, radius: Double, desiredNeighbors: Int, tolerance: Int, minRange: Double = DEFAULT_MINRANGE, maxRange: Double = DEFAULT_MAXRANGE, adjustment: Double = DEFAULT_ADJUSTMENT) : ObservingRangeBasedNetworkModel<T, P, AdaptiveRange.LinkState>

A RangeBasedNetworkModel where each node has its own range, adjusted to keep its number of neighbors close to a target: two nodes are linked when each is within the range of the other, and conditionForRemoval does not hold. Whenever its neighborhood changes, the range of a node converges, by steps of adjustment within minRange and maxRange, until its number of neighbors is within tolerance of desiredNeighbors.

ClosestN

open class ClosestN<T, P : Position> @JvmOverloads constructor(environment: Environment<T, P>, nodeCount: Int, expectedNodes: Int = 0) : NetworkModel<T>

Network model linking every enabled node to its nodeCount closest enabled nodes, and to the enabled nodes that count it among their nodeCount closest; ties are broken by the lowest node id. No node is linked while environment holds fewer than expectedNodes nodes.

CombinedNetworkModel

class CombinedNetworkModel<T>(subRules: List<NetworkModel<T>>) : NetworkModel<T>

A network model that combines multiple subRules all bound to the same environment. If any mandates a link, such link is created (union of all links).

ConditionalClosestN

class ConditionalClosestN<T, P : Position>(environment: Environment<T, P>, nodeCount: Int, expectedNodes: Int, molecule: Molecule, value: T) : ClosestN<T, P>

A ClosestN linking only the nodes whose concentration of molecule is value.

ConnectionBeam

class ConnectionBeam<T>(environment: Environment<T, Euclidean2DPosition>, radius: Double, beamWidth: Double) : ObservingRangeBasedNetworkModel<T, Euclidean2DPosition, Euclidean2DPosition>

Connects two nodes if, throwing a beam from one to the other, there exists at least one path entirely inside the beam that connects the two nodes. This model is ideal for environments with obstacles, where the user wants some tolerance in connection breaking.

ConnectToAccessPoint

class ConnectToAccessPoint<T, P : Position>(environment: Environment<T, P>, radius: Double, accessPointId: Molecule) : AccessPointNetworkModel<T, P, Boolean>

Network model that connects nodes within a specified radius, but connects a node that is not an access point only to access points.

ConnectViaAccessPoint

class ConnectViaAccessPoint<T, P : Position>(environment: Environment<T, P>, radius: Double, accessPointId: Molecule) : AccessPointNetworkModel<T, P, ConnectViaAccessPoint.Role<T>>

Network model that connects each node to its closest access point within range, and to the other nodes within range served by the same access point; access points are connected to each other when within range. The closest access point is the nearest one, ties being broken by the lowest node id.

ConnectWithinDistance

class ConnectWithinDistance<T, P : Position>(environment: Environment<T, P>, range: Double) : RangeBasedNetworkModel<T, P>

it.unibo.alchemist.model.NetworkModel which connects the nodes of environment whose distance is shorter than range.

FullyConnected

class FullyConnected<T>(environment: Environment<T, *>) : NetworkModel<T>

This model connects every node of environment to each and every other.

NoLinks

open class NoLinks<T> : NetworkModel<T>

This model guarantees that no links are created at all.

ObservingRangeBasedNetworkModel

abstract class ObservingRangeBasedNetworkModel<T, P : Position, Observed>(environment: Environment<T, P>, range: Double) : RangeBasedNetworkModel<T, P>

A RangeBasedNetworkModel whose links depend on the state of the nodes, such as their positions or contents: each node exposes it as an Observed, through observeInput, and whether two nodes are linked is a function of their inputs only. Neighborhoods are recomputed whenever the candidate neighbors, by default the nodes within range, change, or the input of the center or of any candidate does.

ObstaclesBreakConnection

class ObstaclesBreakConnection<T, P : Position, Vector>(environment: Environment<T, P>, radius: Double) : ObservingRangeBasedNetworkModel<T, P, P>

Similar to ConnectWithinDistance, but if the environment has obstacles, the links they cross are removed.

OffsetGraphStreamNetworkModel

class OffsetGraphStreamNetworkModel<T, P : Position>(environment: Environment<T, P>, val offset: Int, val graph: Graph) : NetworkModel<T>

A NetworkModel that statically connects the nodes of environment as they were configured by GraphStream. An offset is used to determine the id of the environment's nodes when compared to the one of the provided graph.

RangeBasedNetworkModel

abstract class RangeBasedNetworkModel<T, P : Position>(environment: Environment<T, P>, range: Double) : NetworkModel<T>

A NetworkModel linking each node of environment to the nodes within range of it for which isLinked holds. Neighborhoods follow the nodes within range: isLinked must depend on nothing that changes while they stay in range, models whose links depend on further state extend ObservingRangeBasedNetworkModel instead.