alchemist/it.unibo.alchemist.model.implementations.linkingrules

Package it.unibo.alchemist.model.implementations.linkingrules

Types

abstract class AbstractLocallyConsistentLinkingRule<T, P : Position<out P>?> : LinkingRule<T, P>

open class AdaptiveRange<T, P : Position?> : ConnectWithinDistance<T, P>

This linking rule dynamically searches for the best radius for each device, in such a way that it connects to a certain number of devices.

ClosestN

open class ClosestN<T, P : Position?> : LinkingRule<T, P>

Non local-consistent rule that connect the closest N nodes together.

CombinedLinkingRule

class CombinedLinkingRule<T, P : Position>(subRules: List<LinkingRule<T, P>>) : LinkingRule<T, P>

A meta-rule that combines multiple subRules. If any mandates a link, such link is created (union of all links).

ConditionalClosestN

class ConditionalClosestN<T, P : Position?> : ClosestN<T, P>

A ClosestN rule that also checks that a Molecule has a specific concentration before allowing the connection.

ConnectIfInLineOfSigthOnMap

class ConnectIfInLineOfSigthOnMap<T> @JvmOverloads constructor(maxRange: Double, tolerance: Double) : AbstractLocallyConsistentLinkingRule<T, GeoPosition>

This rule connects nodes that are within maxRange distance, but only if there are not too many obstacles separating their line of sight. The base idea is that line-of-sight distance and routing distance should not differ "too much", as captured by tolerance. tolerance measures the maximum allowed relative difference between the line-of-sight and the route distance. It's default 0.1 (10%) means that if LOS-distance is more than 10% shorter than route-distance, then the nodes are considered disconnected. Route distance is taken two-ways (to account for one-way roads) and the shortest one is considered (wireless signals do not need to follow one-way roads).

ConnectionBeam

class ConnectionBeam<T> : ConnectWithinDistance<T, 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.

ConnectToAccessPoint

class ConnectToAccessPoint<T, P : Position>(radius: Double, accessPointId: Molecule) : ConnectWithinDistance<T, P>

ConnectViaAccessPoint

class ConnectViaAccessPoint<T, P : Position>(radius: Double, accessPointId: Molecule) : ConnectWithinDistance<T, P>

ConnectWithinDistance

open class ConnectWithinDistance<T, P : Position?> : AbstractLocallyConsistentLinkingRule<T, P>

LinkingRule which connects nodes whose euclidean distance is shorter than a given radius.

FullyConnected

class FullyConnected<T, P : Position> : LinkingRule<T, P>

This rule connects each and every node to each and every other.

LinkNodesWithinRoutingRange

class LinkNodesWithinRoutingRange<T> : AbstractLocallyConsistentLinkingRule<T, GeoPosition>

NoLinks

open class NoLinks<T, P : Position?> : AbstractLocallyConsistentLinkingRule<T, P>

This rule guarantees that no links are created at all.

ObstaclesBreakConnection

class ObstaclesBreakConnection<T, P : Position?, Vector?> : ConnectWithinDistance<T, P>

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

OffsetGraphStreamLinkingRule

class OffsetGraphStreamLinkingRule<T, P : Position>(offset: Int, graph: Graph) : LinkingRule<T, P>

A LinkingRule that statically connects nodes 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.

SelectiveAdaptiveRange

open class SelectiveAdaptiveRange<T, P : Position?> : AdaptiveRange<T, P>