alchemist/it.unibo.alchemist.model.implementations.nodes

Package it.unibo.alchemist.model.implementations.nodes

Nodes implementations.

Types

abstract class AbstractCognitivePedestrian<T, P : Position, Vector, A : GeometricTransformation, F : GeometricShapeFactory<P, A>> @JvmOverloads constructor(environment: PhysicsEnvironment<T, P, A, F>, randomGenerator: RandomGenerator, backingNode: Node<T>, age: Age, gender: Gender, danger: Molecule?, group: PedestrianGroup<T, P, A>?, cognitive: CognitiveModel?) : AbstractHeterogeneousPedestrian<T, P, A, F> , CognitivePedestrian<T, P, A>

Implementation of a cognitive pedestrian.

AbstractHeterogeneousPedestrian

abstract class AbstractHeterogeneousPedestrian<T, P : Vector, Position, A : GeometricTransformation, F : GeometricShapeFactory<P, A>> @JvmOverloads constructor(randomGenerator: RandomGenerator, backingNode: Node<T>, age: Age, gender: Gender, group: PedestrianGroup<T, P, A>?) : AbstractHomogeneousPedestrian<T, P, A, F> , HeterogeneousPedestrian<T, P, A>

Implementation of a heterogeneous pedestrian.

AbstractHomogeneousPedestrian

abstract class AbstractHomogeneousPedestrian<T, P : Position, Vector, A : GeometricTransformation, F : GeometricShapeFactory<P, A>> @JvmOverloads constructor(randomGenerator: RandomGenerator, backingNode: Node<T>, group: PedestrianGroup<T, P, A>?) : Node<T> , Pedestrian<T, P, A>

Implementation of a basic pedestrian.

AbstractNode

abstract class AbstractNode<T> : Node<T>

This class realizes an abstract node.

AbstractOrientingPedestrian

abstract class AbstractOrientingPedestrian<T, P : Position, Vector, A : GeometricTransformation, L : ConvexGeometricShape<P, A>, N : ConvexGeometricShape<P, A>, E, F : GeometricShapeFactory<P, A>>(randomGenerator: RandomGenerator, environment: EnvironmentWithGraph<*, T, P, A, N, E>, backingNode: Node<T>, knowledgeDegree: Double, group: PedestrianGroup<T, P, A>?, minArea: Double) : AbstractHomogeneousPedestrian<T, P, A, F> , OrientingPedestrian<T, P, A, L, DefaultEdge>

An abstract OrientingPedestrian, contains an algorithm for the generation of a pseudo-random cognitiveMap. The creation of landmarks is left to subclasses via factory method (see createLandmarkIn).

CellNodeImpl

open class CellNodeImpl?, Vector?> : DoubleNode, CellNode , CellWithCircularArea

CircleNode

open class CircleNode<T> @JvmOverloads constructor(env: Physics2DEnvironment<T>, radius: Double) : AbstractNode<T> , NodeWithShape<T, Euclidean2DPosition, Euclidean2DTransformation>

A it.unibo.alchemist.model.interfaces.Node with a circle shape meant to be added to a it.unibo.alchemist.model.interfaces.environments.PhysicsEnvironment.

CircularDeformableCellImpl

class CircularDeformableCellImpl?, Vector?> : CellNodeImpl , CircularDeformableCell

Implementation of a circular deformable cell.

CognitiveOrientingPedestrian2D

class CognitiveOrientingPedestrian2D<T, N : ConvexPolygon, E> @JvmOverloads constructor(randomGenerator: RandomGenerator, environment: EuclideanPhysics2DEnvironmentWithGraph<*, T, N, E>, backingNode: Node<T>, knowledgeDegree: Double, group: PedestrianGroup2D<T>?, age: Age, gender: Gender, danger: Molecule?) : HomogeneousOrientingPedestrian2D<T, N, E> , CognitivePedestrian<T, Euclidean2DPosition, Euclidean2DTransformation>

A cognitive OrientingPedestrian in the Euclidean world.

CognitiveOrientingPhysicalPedestrian2D

class CognitiveOrientingPhysicalPedestrian2D<T, N : ConvexPolygon, E> @JvmOverloads constructor(incarnation: Incarnation<T, Euclidean2DPosition>, randomGenerator: RandomGenerator, environment: EuclideanPhysics2DEnvironmentWithGraph<*, T, N, E>, nodeCreationParameter: String?, knowledgeDegree: Double, group: PedestrianGroup2D<T>?, age: String, gender: String, danger: Molecule?) : CognitivePhysicalPedestrian2D<T> , OrientingPedestrian<T, Euclidean2DPosition, Euclidean2DTransformation, Ellipse, DefaultEdge>

A cognitive OrientingPedestrian2D capable of physical interactions. TODO(rename it into something like "SmartPedestrian2D"?)

CognitivePedestrian2D

open class CognitivePedestrian2D<T>(randomGenerator: RandomGenerator, environment: Physics2DEnvironment<T>, backingNode: Node<T>, age: Age, gender: Gender, danger: Molecule?, group: PedestrianGroup2D<T>?) : AbstractCognitivePedestrian<T, Euclidean2DPosition, Euclidean2DTransformation, Euclidean2DShapeFactory> , Pedestrian2D<T>

Implementation of a cognitive pedestrian in the Euclidean world.

CognitivePhysicalPedestrian2D

open class CognitivePhysicalPedestrian2D<T> @JvmOverloads constructor(incarnation: Incarnation<T, Euclidean2DPosition>, randomGenerator: RandomGenerator, environment: Physics2DEnvironment<T>, nodeCreationParameter: String?, age: String, gender: String, danger: Molecule?, group: PedestrianGroup2D<T>?) : CognitivePedestrian2D<T> , PhysicalPedestrian2D<T>

A cognitive pedestrian capable of physical interactions, modeled as a PhysicalPedestrian2D. comfortRay changes dynamically depending on whether the pedestrian wants to evacuate or not.

DoubleNode

open class DoubleNode : AbstractNode<Double>

EnvironmentNodeImpl

class EnvironmentNodeImpl : DoubleNode, EnvironmentNode

HeterogeneousPedestrian2D

class HeterogeneousPedestrian2D<T> @JvmOverloads constructor(incarnation: Incarnation<T, Euclidean2DPosition>, randomGenerator: RandomGenerator, environment: Physics2DEnvironment<T>, age: Any, gender: String, group: PedestrianGroup2D<T>?, nodeCreationParameter: String?) : AbstractHeterogeneousPedestrian<T, Euclidean2DPosition, Euclidean2DTransformation, Euclidean2DShapeFactory> , Pedestrian2D<T>

A pedestrian with heterogeneous characteristics. Requires a bidimensional environment with support for physics (Physics2DEnvironment).

HomogeneousOrientingPedestrian2D

open class HomogeneousOrientingPedestrian2D<T, N : ConvexPolygon, E> @JvmOverloads constructor(randomGenerator: RandomGenerator, environment: EuclideanPhysics2DEnvironmentWithGraph<*, T, N, E>, backingNode: Node<T>, knowledgeDegree: Double, minSide: Double, maxSide: Double, group: PedestrianGroup2D<T>?) : AbstractOrientingPedestrian<T, Position2D, Transformation2D, Ellipse, N, E, ShapeFactory> , Pedestrian2D<T>

A homogeneous OrientingPedestrian in the Euclidean world. Landmarks are represented as Ellipses, which can model the human error concerning both the exact position of a landmark and the angles formed by the connections between them. This class accepts an environment whose graph contains ConvexPolygonal nodes.

HomogeneousOrientingPhysicalPedestrian2D

class HomogeneousOrientingPhysicalPedestrian2D<T, N : ConvexPolygon, E> @JvmOverloads constructor(incarnation: Incarnation<T, Euclidean2DPosition>, randomGenerator: RandomGenerator, environment: EuclideanPhysics2DEnvironmentWithGraph<*, T, N, E>, nodeCreationParameter: String?, knowledgeDegree: Double, group: PedestrianGroup2D<T>?) : HomogeneousPhysicalPedestrian2D<T> , OrientingPedestrian<T, Euclidean2DPosition, Euclidean2DTransformation, Ellipse, DefaultEdge>

A homogeneous OrientingPedestrian2D capable of physical interactions.

HomogeneousPedestrian2D

open class HomogeneousPedestrian2D<T> @JvmOverloads constructor(randomGenerator: RandomGenerator, environment: Physics2DEnvironment<T>, backingNode: Node<T>, group: PedestrianGroup2D<T>?) : AbstractHomogeneousPedestrian<T, Euclidean2DPosition, Euclidean2DTransformation, Euclidean2DShapeFactory> , Pedestrian2D<T>

Implementation of a homogeneous pedestrian in the Euclidean world.

HomogeneousPhysicalPedestrian2D

open class HomogeneousPhysicalPedestrian2D<T> @JvmOverloads constructor(incarnation: Incarnation<T, Euclidean2DPosition>, randomGenerator: RandomGenerator, environment: Physics2DEnvironment<T>, nodeCreationParameter: String?, group: PedestrianGroup2D<T>?) : HomogeneousPedestrian2D<T> , PhysicalPedestrian2D<T>

A homogeneous pedestrian capable of physical interactions, modeled as a PhysicalPedestrian2D. comfortRay is statically defined to be equal to its shape radius.

IntegerNode

abstract class IntegerNode : AbstractNode<Integer>

IntNode

open class IntNode(env: Environment<*, *>) : AbstractNode<Int>

An integer node.

LsaNode

class LsaNode : AbstractNode<List<ILsaMolecule>> , ILsaNode

This class realizes a node with LSA concentration.

ProtelisNode

class ProtelisNode?> : AbstractNode<Any> , DeviceUID, ExecutionEnvironment