Serialized Form

Package cz.cuni.amis.pogamut.episodic.decisions

Class cz.cuni.amis.pogamut.episodic.decisions.Action extends Node implements Serializable

serialVersionUID: 1L

Serialized Fields

possibleSubTrees

int possibleSubTrees

subNodes

HashMap<K,V> subNodes

Each Action node can have unlimited number of Intention subnodes. The only restriction is that no two subnodes can have identical name. These subnodes are goals that all need to be completed in order to perform this action - they are AND nodes.

atomicActions

HashMap<K,V> atomicActions

Each Action node can have unlimited number of AtomicAction subnodes. The only restriction is that no two subnodes can have identical name. These subnodes are atomic actions that will be executed once all goals are satisfied and agent is performing this action. It is reasonable that action nodes without any subgoals will have at least one atomic action attached to it.

Class cz.cuni.amis.pogamut.episodic.decisions.AffordanceSlot extends Object implements Serializable

serialVersionUID: 1L

Serialized Fields

type

String type

Type of a slot specifies the class of items that can satisfy (fill) the affordance slot. Any item of same item type can be linked with with the slot and no item that is not of this type cannot be linked with it.

id

int id

Unique ID of the slot. Used as an ID of vertex representing this node when visualizing decision tree.

idSet

boolean idSet

Because ID of decision nodes and slots are not set automatically this indicator determines whether it is OK to retreive the ID. ID that was not set yet, cannot be retreived.

Class cz.cuni.amis.pogamut.episodic.decisions.AtomicAction extends Node implements Serializable

serialVersionUID: 1L

Class cz.cuni.amis.pogamut.episodic.decisions.DecisionTree extends Object implements Serializable

serialVersionUID: 1L

Serialized Fields

topLevelGoals

HashMap<K,V> topLevelGoals

Map of all possible top-level goals agent can have. They are indexed by their name (so there cannot be two top-level goals with identical names). Through here it is possible to get to any node in the decision trees.

numberOfAtomicActions

int numberOfAtomicActions

numberOfNodes

int numberOfNodes

This number is without atomic actions. It only includes intentions and actions.

branchFactor

ArrayList<E> branchFactor

Class cz.cuni.amis.pogamut.episodic.decisions.Intention extends Node implements Serializable

serialVersionUID: 1L

Serialized Fields

possibleSubTrees

int possibleSubTrees

subNodes

HashMap<K,V> subNodes

Each Intention node can have unlimited number of Action subnodes. The only restriction is that no two subnodes can have identical name. These subnodes are actions that can be performed in order to satisfy this intention - they are OR nodes.

Class cz.cuni.amis.pogamut.episodic.decisions.Node extends Object implements Serializable

serialVersionUID: 1L

Serialized Fields

name

String name

Name of the node is used to identify and index the nodes agent's memory. Therefore no two nodes in the same level can have identical names (e.g. no two top-level goals, no two children of another node). Also node cannot have a descendant (child, child's child...) with identical name. There can be two nodes with same name though, if they are not children of the same parent node and one is not an ancestor (parent, grandparent...) of the other one.

attractivity

int attractivity

Specified in XML file. Helps determine when to forget node.

parent

Node parent

A reference to the parent node in the decision tree. Parents of intentions (goals) and atomic action will be actions. Parents of actions will be intention nodes. Only nodes without a parent are the top-level goals - roots of decision tree.

id

int id

Unique ID of the node. Used as an ID of vertex representing this node when visualizing decision tree.

idSet

boolean idSet

Because ID of decision nodes and slots are not set automatically this indicator determines whether it is OK to retreive the ID. ID that was not set yet, cannot be retreived.

type

NodeType type

Type of the Node. Node can be either action, intention (goal) or atomic action.

affordances

Map<K,V> affordances

Actions and Intetions can have affordance slots attached to them. These slots are kept in the affordances list. In order to perform an action or satisfy a goal, all its slots have to be filled first. Once the slot is filled, its equivalent in memory of experienced episode will be linked with the object that satisfied the slot.

associatedSchemaNode

SchemaEpisodeNode associatedSchemaNode

All nodes are associated with equivalent nodes in schemabag once the equivalent node is created there. SchemaNodes can be used to create average episodes or count number of experienced of an episode.

See Also:

SchemaEpisodeNode

Package cz.cuni.amis.pogamut.episodic.episodes

Class cz.cuni.amis.pogamut.episodic.episodes.AgeInterval extends Object implements Serializable

serialVersionUID: 1L

Serialized Fields

minAge

int minAge

Lower bound for age of episodes in a chronobag (in days).

maxAge

int maxAge

Upper bound for age of episodes in a chronobag (in days).

Class cz.cuni.amis.pogamut.episodic.episodes.Chronobag extends Object implements Serializable

serialVersionUID: 1L

Serialized Fields

idGenerator

IdGenerator idGenerator

A reference to ID generator structure, that will provide the unique IDs to all inside node. This unique IDs are mostly needed when identifying the visualized vertices (because nodes can have identical names).

mem

AgentMemory mem

A reference to the parent structure. It should be possible to access decision tree, schemas or other parts of memory via this reference.

id

int id

ID of this chronobag. Used as an ID of vertex representing this chronobag when visualizing Chronobag View.

landmark

boolean landmark

Determines whether this chronobag is old enough to pass a landmark threshold. No episodes are forgotten from landmark episodes.

level

int level

Specifies the level of abstraction of temporal location of chronobag's episodes. Chronobag can contain episodes from single day or from longer time frame (e.g. a week). Level 0 zero means the chronobag is daily chronobag. Higher level means the chronobag contains episodes from longer time period.

Default value is 0: daily chronobag.

finishedEpisodes

ArrayList<E> finishedEpisodes

List of finished episodes. Most episodes remembered will be in this list. An episode gets here from currentEpisodes once it is finished. In past chronobags (all except the current day) all episodes are stored here, because all episodes are already finished.

currentEpisodes

HashMap<K,V> currentEpisodes

List of current episodes. This is a list of episodes that were not finished yet. Each time a new action is performed, it has to be added to an episode in this list. Only current chronobag will be using this list (it will be empty for past chronobags).

An episode will be moved to finishedEpisodes once its root node is finished, its goal disappears from short-term memory or during agent's sleep.

lastEpisode

Episode lastEpisode

Link to the episode that was performed last - parent episode of last performed action. Used to create the temporal sequence of episodes.

firstEpisode

Episode firstEpisode

Link to the first episode in this chronobag. Used to display episodes in correct sequence when visualizing the chronobag.

age

AgeInterval age

Age contains information about the age of a chronobag. Age of all episodes in chronobag should fit inside this interval.

older

Chronobag older

Older chronobag in the list when arranged by their age. Episodes in older chronobag were experienced just before episodes in this chronobag.

Chronobags can appear on different levels of abstraction, e.g. daily chronobags, week chronobags... This points to this next chronobag in the same level of abstraction. Chronobags of other levels forms separate chain of chronobags.

younger

Chronobag younger

Yonger chronobag in the list when arranged by their age. Episodes in younger chronobag were experienced just after episodes in this chronobag.

Chronobags can appear on different levels of abstraction, e.g. daily chronobags, week chronobags... This points to this next chronobag in the same level of abstraction. Chronobags of other levels forms separate chain of chronobags.

nextLevel

Chronobag nextLevel

Reference to the youngest chronobag in the next higher level of abstraction. Chronobags can be devided into levels according the lenght of their age interval (daily chronobags, weekly chronobags). Higher levels of abstraction are those where the lenght of this interval is higher.

newNodeAdded

boolean newNodeAdded

An indicator whether new node was added into this chronobags since its visualization was last refreshed. Set to true when new node is added. Set to false when the chronobag is redrawed.

numberOfEpisodeNodes

int numberOfEpisodeNodes

Count the total number of EpisodeNode nodes in the chronobag.

numberOfUsedObjects

int numberOfUsedObjects

Count the total number of ObjectNodes connections to the ObjectSlots in this chronobag. Each object attached to a node in chronobag is counted as one node when it comes to calculating how big is the chronobag capacity.

maxNumberOfNodes

int maxNumberOfNodes

Maximum number of nodes the chronobag could contain. For daily chronobags it is calculated before first forgetting process is triggered. For abstract chronobags it is sum of daily values from daily chronobags covering the same time period

score

double score

Score of a chronobag. It is used to determine how many episode nodes can be kept in the chronobag after the "forgetting" process.

objectNodes

HashMap<K,V> objectNodes

Map of ObjectNodes remembered by the agent. This map is shared among the chronobags so it is possible to find all usages of specified object. Object are indexed by their unique name.

In episodes object nodes are connected with the affordance slots they were used in.

Class cz.cuni.amis.pogamut.episodic.episodes.Episode extends Object implements Serializable

serialVersionUID: 1L

Serialized Fields

root

EpisodeNode root

The EpisodeNode representing top-level goal of this episode (root of episode tree).

parentChronobag

Chronobag parentChronobag

Reference to the Chronobag this episode belongs to. The age of an episode has to be deduced from the age of its parent chronobag.

finished

boolean finished

An indicator whether the episode was finished. All episodes are created as not finished. It is finished when its top-level goal is finished.

Episode can be transferred into finishedEpisodes list in a chronobag even when it is not finished. This happens to all episodes that had to be interrupted because agent went to sleep at the end of a day. But once it is finished, it cannot appear in the currentEpisodes list in a chronobag.

idEpisode

int idEpisode

This ID is different than other node IDs in memory. This is not used for visualize purposes. It is used to determine when two episodes in different chronobags are copies of one episode and when they are both unique episodes.

idGen

IdGenerator idGen

A reference to ID generator structure, that will provide the unique IDs to all inside node. This unique IDs are mostly needed when identifying the visualized vertices (because nodes can have identical names).

copyScore

double copyScore

A score of an episode that is used to determine whether it should be copied to more abstract chronobag. Initial value is 0 and it is relalculated each night. Once the value passes given threshold, episode copy is created and added to more abstract chronobag. Episode can be copied only once.

copied

boolean copied

Indicator telling if the episode was already copied to more abstract chronobag. Each episode can be copied only once.

deleted

boolean deleted

When last of episode nodes (root) of this episode is deleted. It sets this flag to true and it means whole episode should be deleted.

next

ArrayList<E> next

The next field links Episodes of a chronobag in order they were executed. It contains episodes executed just after current episode.

If episode was interrupted it can have more than one successor. Episodes in next list are ordered in order they were executed - first interruptions are at the beginning, final successor is at the end.

previous

ArrayList<E> previous

The previous field contains Episodes of a chronobag that were executed just before this episode.

If episode was interrupted it can have more than one predecessor. Episodes in next list are ordered in reverse order than they were executed - first predecessors are at the end, last interruption is at the beginning.

mem

AgentMemory mem

Class cz.cuni.amis.pogamut.episodic.episodes.EpisodeNode extends Object implements Serializable

serialVersionUID: 1L

Serialized Fields

id

int id

ID of this node. Used as an ID of vertex representing this node when visualizing given Chronobag.

name

String name

Name of the intention, action or atomic action that is represented by this node. Same as the name of an associated node.

associatedNode

Node associatedNode

Equivalent of this node in the decision tree. It is a reference to the node that was chosen to be performed and a way to access the associated SchemaEpisodicNode.

parent

EpisodeNode parent

Reference to a parent EpisodeNode in the episode tree. Only top-level goal (root of an episode) does not have a parent.

root

Episode root

Reference the Episode structure representing whole episode this node belongs to. Via this reference it is possible to access outer memories.

children

HashMap<K,V> children

Map of EpisodeNodes that are subnodes of this node in the episode tree. Node without children is an atomic action.

The map is indexed by the name of the child node.

firstChild

Map<K,V> firstChild

Reference to a direct child node that was executed first. Used to provide the correct temporal sequence of child nodes.

lastChild

Map<K,V> lastChild

Reference to a direct child node that was executed last. Used to provide the correct temporal sequence of child nodes.

successors

Map<K,V> successors

Reference to a sibling node (node with same parent) that was executed first after this node. Used to provide the correct temporal sequence of child nodes.

predecessors

Map<K,V> predecessors

Reference to a sibling node (node with same parent) that was executed last before this node. Used to provide the correct temporal sequence of child nodes.

slots

HashMap<K,V> slots

Collection of all affordance slots that attached to this node. Slots are in a map indexed by their type.

finished

boolean finished

Indicator whether this node was correctly finished. Node is finished when an agent decides to throw it out of short-term memory, because it was completed or could not be completed.

Nodes in finished episodes can contain unfinished nodes if they were interrupted in an unusual way (top-level goal suddenly disappeared from short-term memory).

succeeded

boolean succeeded

Indicator whether this node was successfully finished.

score

double score

Score of a node. Used to determine if it is okay to forget the node.

numberOfSubNodes

int numberOfSubNodes

numberOfSubNodesWithObjects

int numberOfSubNodesWithObjects

countAtCreation

int countAtCreation

timeStart

String timeStart

timeFinish

String timeFinish

consumed

boolean consumed

Class cz.cuni.amis.pogamut.episodic.episodes.ObjectNode extends Object implements Serializable

serialVersionUID: 1L

Serialized Fields

name

String name

Name of the item represented by this object node. No two items should have identical name.

id

int id

ID of this node. Used as an ID of vertex representing this node when visualizing Chronobag View.

usedAt

HashSet<E> usedAt

Set of all slots, this object was used in. An object can be used in several slots of different type, in several different episodes belonging to different chronobags or in several slot in one episode. For each object here it can be found where the object was used.

Class cz.cuni.amis.pogamut.episodic.episodes.ObjectSlot extends Object implements Serializable

serialVersionUID: 1L

Serialized Fields

id

int id

ID of this node. Used as an ID of vertex representing this node when visualizing Chronobag View.

type

String type

Type of an object that can fill this slot. Each of the slots attached to an episodic node has to have a unique type.

parentNode

EpisodeNode parentNode

Reference to EpisodeNode this slot is attached to.

objects

HashMap<K,V> objects

Map of ObjectNodes representing objects that satisfy this affordance. Usually there will be just one object, but it is possible to have several objects of the same type in one slot. Each connection to object node is assigned a double score (hence a map). Scores is used to determine if the link between the episode node and the object node can be forgotten.

Package cz.cuni.amis.pogamut.episodic.memory

Class cz.cuni.amis.pogamut.episodic.memory.AgentMemory extends Object implements Serializable

serialVersionUID: 1L

Serialized Fields

sem

Semaphore sem

listeners

EventListenerList listeners

idGenerator

IdGenerator idGenerator

Instance of IdGenerator class providing unique IDs to all nodes in agent memory. Unique IDs are needed mainly for visualizing purposes.

lastDay

int lastDay

Variable storing the number of day when agent performed last action. Used to determine if new day has already started when agent begins sleeping, so that memory reorganization process can be triggered.

If agent did not perform any action yet, its value is -1.

decisionTree

DecisionTree decisionTree

Memory structure mirroring decision nodes from decision making module. Needs to be initialized before the memory can work correctly. Most of the nodes in agent's memory store a reference to the associated node in decision trees.

See Also:

DecisionTree

present

Chronobag present

Current chronobag storing episodes from the actual day. Each time a new action is performed by the agent, it is added to one episode in this chronobag. During memory reorganization process it is replaced by a new empty chronobag and added into the list of past chronobags.

past

HashSet<E> past

List of all the past chronobags in agent's memory. Chronobag can get here during memory reorganization process when the current chronobag is moved to the set of past chronobags or when new chronobags with extended temporal coverage are created. Chronobags are sorted by age in several parallel lists with each list containing chronobags of one level of time abstraction (daily, weekly...).

pastSequenceEnds

Map<K,V> pastSequenceEnds

schemas

SchemaBag schemas

Schema bag accumullates all different experiences instances of episodes into aggregated schemas. Apart from the capability to retrieve universal episodes it gives us a way how to tell what sub-episodes happen more often that others and it helps us to more efficiently store the concrete episodes by providing a way to derive some of the nodes from what is only a part of complete episode tree.

Class cz.cuni.amis.pogamut.episodic.memory.IdGenerator extends Object implements Serializable

serialVersionUID: 1L

Serialized Fields

id

int id

ID to be returned. None of the nodes have this or higher id.

Package cz.cuni.amis.pogamut.episodic.schemas

Class cz.cuni.amis.pogamut.episodic.schemas.SchemaBag extends Object implements Serializable

serialVersionUID: 1L

Serialized Fields

idGenerator

IdGenerator idGenerator

A reference to ID generator structure, that will provide the unique IDs to all inside node. This unique IDs are mostly needed when identifying the visualized vertices (because nodes can have identical names).

memory

AgentMemory memory

A reference to the parent structure. It should be possible to access decision tree, chronobags or other parts of memory via this reference.

numberOfNodes

int numberOfNodes

Count the total number of nodes in the schemabag. Used mostly to determine whether there was new node added since last refresh of schemabag visualization, so that it can be redrawed.

id

int id

ID of the schemabag. Used as an ID of vertex representing the schemabag when visualizing Chronobag View.

schemaENodes

HashMap<K,V> schemaENodes

schemaENodes is a collection of all SchemaEpisodicNodes in the SchemaBag. Since upon its creation each node is mutually associated with a node in decision tree, these nodes are in a map indexed by the unique ID of their associated nodes.

schemaONodes

HashMap<K,V> schemaONodes

schemaENodes is a collection of all SchemaObjectNodes in the SchemaBag. Since each item has to have a unique name, all nodes are indexed in a map indexed by the name of an item.

counters

org.apache.commons.collections15.multimap.MultiHashMap<K,V> counters

counters is a collection of all SchemaCounters in the SchemaBag. In order to quickly access any counter, counters are indexed in a multihashmap. Index of a counter is calculated as the sum of IDs of all nodes it refers to. So a single counters (those counting appearences of each node separately) is indexed by an ID of particular node. Given one SchemaCouter it is quickly possible to count the index of another counter representing the same set of nodes plus/minus specified nodes. Since several sums can add to one identical number, counters need to be stored in a multimap.

schemaMessageCommand

SchemaBag.SchemaMessageCommand schemaMessageCommand

Instantion of a SchemaMessageCommand class that is passed to visualizer so that it can recieve up to date information about SchemaCounters.

See Also:

SchemaBag.SchemaMessageCommand

lastIds

Collection<E> lastIds

requiredIds

Collection<E> requiredIds

If the trace of nodes is very similar with the one when the schema was last updated, it may need be wanted to increase all the counters. Only the counters containing new nodes should be increased. IDs of these nodes are stored in this collection.

Class cz.cuni.amis.pogamut.episodic.schemas.SchemaBag.SchemaMessageCommand extends Object implements Serializable

Class cz.cuni.amis.pogamut.episodic.schemas.SchemaCounter extends Object implements Serializable

serialVersionUID: 1L

Serialized Fields

schemaNodes

Collection<E> schemaNodes

Collection of SchemaEpisodeNodes contributing to the set of nodes defining this counter. Can be empty if this is single counter for a SlotContent.

contentNodes

Collection<E> contentNodes

Collection of SlotContents contributing to the set of nodes defining this counter. Can be empty if this is single counter for a SchemaEpisodeNode.

key

int key

Key under which this counter is stored in the list of all counters in SchemaBag. It is the sum of IDs of all nodes contributing to the set of nodes defining this counter

count

int count

Actual count number of this counter. It says how many times given nodes where executed together with the use of given objects.

totalCount

int totalCount

totalCount is similar to count, but it is increased always when the nodes are executed even if it is during the same execution of an action. If duration of an atomic action is 100, its total count will be increased by 100, but its count just by 1.

Class cz.cuni.amis.pogamut.episodic.schemas.SchemaEpisodeNode extends Object implements Serializable

serialVersionUID: 1L

Serialized Fields

id

int id

ID of this node. Used as an ID of vertex representing this chronobag when visualizing Schemas.

name

String name

Name of the intention, action or atomic action that is represented by this schema node. Same as the name of an associated node.

associatedNode

Node associatedNode

Reference to the associated decision node. It can be either action, intention (goal) or atomic action. Each schema nodes is associated with exactly one decision node.

slots

HashMap<K,V> slots

Same as actions and intetions in decision tree, their schema equivalents can have affordance slots attached to them. These slots are kept in the slots list. Each slot is equivalent with exactly one affordance slot in decision tree. Through schema slots it is possible to find out how many times was each item used to satisfy the given slot.

counts

org.apache.commons.collections15.multimap.MultiHashMap<K,V> counts

counts is a collection of all SchemaCounters this node contributes to. In order to quickly access any counter, counters are indexed in a multihashmap. Index of a counter is calculated as the sum of IDs of all nodes it refers to, but when accessing a counter from the inside of the node, nodes id is not added to the sum. So a single counters of nodes can always be accessed on zero index.

Class cz.cuni.amis.pogamut.episodic.schemas.SchemaObjectNode extends Object implements Serializable

serialVersionUID: 1L

Serialized Fields

id

int id

ID of this node. Used as an ID of vertex representing this chronobag when visualizing Schemas.

name

String name

Unique name of the item this node is representing.

usedIn

HashMap<K,V> usedIn

In schemas these nodes are linked together with slots they were used in via the SlotContent structure. Thus it is possible to determine how many times each item was used to perform each node. Each SlotContent is linking exactly one SchemaSlot and one SchemaObjectNode.

This is the map of all SlotContents pointing to this SchemaObjectNode indexed by the ID of the SchemaSlot they linking the object with.

Class cz.cuni.amis.pogamut.episodic.schemas.SchemaSlot extends Object implements Serializable

serialVersionUID: 1L

Serialized Fields

id

int id

ID of this node. Used as an ID of vertex representing this chronobag when visualizing Schemas.

type

String type

Type of a slot specifies the class of items that can satisfy (fill) the affordance slot. Any item of same item type can be linked with with the slot and no item that is not of this type cannot be linked with it.

filledBy

HashMap<K,V> filledBy

Map of all SlotContent objects that are pointing to this slot.

SlotContents are indexed by a name of item they are connecting the slot with.

Class cz.cuni.amis.pogamut.episodic.schemas.SlotContent extends Object implements Serializable

serialVersionUID: 1L

Serialized Fields

id

int id

ID of this node. Used as an ID of vertex representing this chronobag when visualizing Schemas.

slot

SchemaSlot slot

Reference to the SchemaSlot object on one end of the link between a slot and an object created by this slot content.

object

SchemaObjectNode object

Reference to the SchemaObjectNode object on one end of the link between a slot and an object created by this slot content.

counts

org.apache.commons.collections15.multimap.MultiHashMap<K,V> counts

counts is a collection of all SchemaCounters this node contributes to. In order to quickly access any counter, counters are indexed in a multihashmap. Index of a counter is calculated as the sum of IDs of all nodes it refers to, but when accessing a counter from the inside of the node, nodes id is not added to the sum. So a single counters of nodes can always be accessed on zero index.

Package cz.cuni.amis.pogamut.episodic.visualizer

Class cz.cuni.amis.pogamut.episodic.visualizer.VisualizationEvent extends EventObject implements Serializable

Serialized Fields

type

VisualizationEventType type

mem

AgentMemory mem

time

String time