alchemist/it.unibo.alchemist.model.actions

Package-level declarations

Generic actions implementations.

Types

AbstractAction

abstract class AbstractAction<T> : Action<T>

An abstract class facility with some generic methods implemented.

AbstractActionOnSingleMolecule

abstract class AbstractActionOnSingleMolecule<T> : AbstractAction<T>

This class offers the basic structures to provide operations with numeric concentrations on a single molecule.

AbstractConfigurableMoveNode

abstract class AbstractConfigurableMoveNode<T, P : Position?> : AbstractMoveNode<T, P>

An abstract class that factorizes code for multiple different movements.

AbstractEuclideanConfigurableMoveNode

abstract class AbstractEuclideanConfigurableMoveNode<T, P : Position, Vector>(environment: Environment<T, P>, node: Node<T>, routing: RoutingStrategy<T, P>, target: TargetSelectionStrategy<T, P>, speed: SpeedSelectionStrategy<T, P>) : AbstractConfigurableMoveNode<T, P>

It's an AbstractConfigurableMoveNode in the Euclidean world, which provides a default interpolatePositions that is accurate with respect to the target given and the current maximum walking distance.

AbstractLocalAction

abstract class AbstractLocalAction<T> : AbstractAction<T>

AbstractMoveNode

abstract class AbstractMoveNode<T, P : Position?> : AbstractAction<T>

This action moves a node inside a given environment.

BrownianMove

class BrownianMove<T, P : Position?> : AbstractMoveNode<T, P>

Moves the node randomly.

CameraInjectVisibleNodeClosestToDistance

class CameraInjectVisibleNodeClosestToDistance(node: Node<Any>, environment: Physics2DEnvironment<Any>, distance: Double, visionMolecule: Molecule, targetMolecule: Molecule) : AbstractAction<Any>

Given a list of VisibleNode associated to visionMolecule, it finds the closest to a point located at distance from node in the direction of node's heading, and injects its position in targetMolecule.

CameraSee

class CameraSee @JvmOverloads constructor(node: Node<Any>, environment: Physics2DEnvironment<Any>, val distance: Double, val angle: Double, outputMolecule: Molecule = SimpleMolecule("vision"), filterByMolecule: Molecule? = null) : AbstractAction<Any>

Checks nodes in the environment and writes in outputMolecule the list of it.unibo.alchemist.model.VisibleNode, containing filterByMolecule. distance and angle define the field of view.

ConstantDistanceRandomWalk

class ConstantDistanceRandomWalk<T>(node: Node<T>, reaction: Reaction<T>, environment: Environment<T, Euclidean2DPosition>, randomGenerator: RandomGenerator, distance: Double, speed: Double) : GenericRandomWalker<T>

Moves for distance toward a uniformly random chosen direction at a constant speed, then changes direction and walks another distance, and so on.

FollowAtDistance

class FollowAtDistance<T>(node: Node<T>, reaction: Reaction<T>, environment: Environment<T, Euclidean2DPosition>, target: Molecule, distance: Double, speed: Double) : AbstractAction<T>

Makes the Node follow a target defined in a Molecule with some speed, but keeping a distance from it.

GenericRandomWalker

open class GenericRandomWalker<T>(node: Node<T>, reaction: Reaction<T>, environment: Environment<T, Euclidean2DPosition>, randomGenerator: RandomGenerator, speed: Double, distanceDistribution: RealDistribution) : AbstractEuclideanConfigurableMoveNode<T, Euclidean2DPosition>

Chooses random targets in a direction extracted from randomGenerator at a distance extracted from distanceDistribution. Moves the node towards the targets at the given constant speed. Changes target on collision.

LevyWalk

class LevyWalk<T> @JvmOverloads constructor(node: Node<T>, reaction: Reaction<T>, environment: Environment<T, Euclidean2DPosition>, randomGenerator: RandomGenerator, speed: Double, scale: Double = 1.0, shape: Double = 1.0) : GenericRandomWalker<T>

Selects a target based on a random direction extracted from randomGenerator, and a random distance extracted from a ParetoDistribution of parameters scale and shape. Moves toward the targets at a constant speed and changes targets on collision.

MoveForwardAndTeleport

class MoveForwardAndTeleport<T, P : Position2D?> : AbstractMoveNode<T, P>

Moves the node along the x axis up to coordinate getMaxX, with steps of size getDeltaX.

MoveToTarget

class MoveToTarget<T, P : Position2D?> : AbstractConfigurableMoveNode<T, P>

Movement towards a target defined as a concentration.

RemoveNode

class RemoveNode<T> : AbstractAction<T>

Removes the current node from the environment.

SetLocalMoleculeConcentration

class SetLocalMoleculeConcentration<T> : AbstractActionOnSingleMolecule<T>

ToggleMolecule

open class ToggleMolecule<T>(node: Node<T>, molecule: Molecule, concentration: T) : AbstractAction<T>

Treats molecule as a switch:

ToggleMoleculeRandomly

open class ToggleMoleculeRandomly<T>(node: Node<T>, randomGenerator: RandomGenerator, molecule: Molecule, concentration: T, odds: Double) : ToggleMolecule<T>

Treats molecule as a probabilistic switch: