alchemist-implementationbase/it.unibo.alchemist.model.actions

Package-level declarations

Types

abstract class AbstractAction<T>(val reaction: Reaction<T>) : Action<T>

Base implementation of an Action owned by reaction, independent of the kind of host.

abstract class AbstractActionOnSingleMolecule<T>(reaction: NodeReaction<T>, val molecule: Molecule) : AbstractLocalAction<T>

A node-bound action that modifies the concentration of a single molecule.

AbstractConfigurableMoveNode

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

A movement combining three strategies: the next target to reach, the route to follow, and the speed to move at.

AbstractLocalAction

abstract class AbstractLocalAction<T>(reaction: NodeReaction<T>) : AbstractNodeAction<T>

Base implementation of an Action executed on the node hosting its NodeReaction.

AbstractMoveNode

abstract class AbstractMoveNode<T, P : Position> : AbstractLocalAction<T>

A node-bound action moving its node in environment.

AbstractNodeAction

abstract class AbstractNodeAction<T>(reaction: Reaction<T>, val targetNode: Node<T>) : AbstractAction<T>

Base implementation of an Action executed on a target targetNode, owned by a reaction with any host.

BrownianMove

class BrownianMove<T, P : Position> @JvmOverloads constructor(environment: Environment<T, P>, reaction: Reaction<T>, node: Node<T> = reaction.host as? Node<T> ?: error( "${BrownianMove::class.simpleName} must either be provided with a node " + "or be owned by a reaction hosted by a node", ), randomGenerator: RandomGenerator, range: Double) : AbstractNodeAction<T>

Moves the target node randomly, by at most range along each dimension at every execution.

MoveForwardAndTeleport

class MoveForwardAndTeleport<T, P : Position2D>(environment: Environment<T, P>, reaction: NodeReaction<T>, val deltaX: Double, val minX: Double, val maxX: Double) : AbstractMoveNode<T, P>

Moves the node along the x axis up to maxX, with steps of size deltaX; once beyond maxX, the node is teleported back to minX. It mimics the movement of a node in a cylindrical environment.

MoveToTarget

class MoveToTarget<T, P : Position2D>(environment: Environment<T, P>, reaction: NodeReaction<T>, trackMolecule: Molecule, speed: Double) : AbstractConfigurableMoveNode<T, P>

Moves the node at speed towards the position stored as concentration of trackMolecule.

RemoveNode

class RemoveNode<T>(environment: Environment<T, *>, reaction: NodeReaction<T>) : AbstractLocalAction<T>

Removes the node owning this action from environment.

SetLocalMoleculeConcentration

class SetLocalMoleculeConcentration<T>(reaction: NodeReaction<T>, molecule: Molecule, value: T) : AbstractActionOnSingleMolecule<T>

Sets the concentration of molecule in the node owning this action to value.

ToggleMolecule

open class ToggleMolecule<T>(reaction: NodeReaction<T>, molecule: Molecule, concentration: T) : AbstractLocalAction<T>

Treats molecule as a switch:

ToggleMoleculeRandomly

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

Treats molecule as a probabilistic switch: