{"data":{"markdownRemark":{"html":"

Actions and Sequences are used to define a sequence of actions for the agents to follow at every step, or at setup.

\n

Executing Action in Sequences

\n

A Sequence is a list of actions that are executed consecutively. Sequences are composable, which means a sequence can be a list of other sequences as well as actions. Multiple sequences can be run in a single setup() or step().

\n

Every sequence needs to be run in order for the sequence to be executed.

\n

Creating and running an empty Sequence (Java)

\n
public class MyClass extends AgentBasedModel<GlobalState> {\n  ...\n\n  run(Sequence.create());\n\n  ...\n}
\n

Actions have to be created for a specific class. It is best practice to create actions inside the class of the Agent the action is being defined for.

\n

When creating an action, two parameters need to defined.

\n
    \n
  1. The agent that will execute this action
    2. \n
  2. The function to be executed by the agent
    3. \n
\n

Creating actions and adding them to a sequence (Java)

\n
public static Action<AgentA> sendMessageToAgentB =\n  Action.create(AgentA.class, agentA -> { /** send message */ });\n\npublic static Action<AgentB> recieveMessage =\n  Action.create(AgentB.class, agentB -> { /** recieve message */ });\n\nrun (\n\tSequence.create(\n\t\tsendMessageToAgentB,\n\t\trecieveMessage\n\t)\n);
\n

The run method can also take a list of actions which it will execute as though it's a sequence, so the above code could also be written like this.

\n

(Java)

\n
public static Action<AgentA> sendMessageToAgentB =\n  Action.create(AgentA.class, agentA -> { /** send message */ });\n\npublic static Action<AgentB> recieveMessage =\n  Action.create(AgentB.class, agentB -> { /** recieve message */ });\n\nrun (\n  \tsendMessageToAgentB,\n  \trecieveMessage\n);
\n
\nAn action within a sequence will only be executed by an agent if that agent has received a message. If an action needs to be executed by all agents of a type, even if some of those agents have not received a message, this action needs to be at the beginning of a new sequence.\n
\n

Message passing(Java)

\n
//If AgentB isn't sent message, it will not do other processing\nrun (\n  Sequence.create(\n    AgentA.conditionallySendMessage(),\n    AgentB.recieveMessageActionAndDoOtherProcessing())\n  ),\n\n  //Split other processing into another sequence to ensure all AgentB do processing\n  Sequence.create(\n    AgentA.conditionallySendMessage()),\n    AgentB.recieveMessageAction())\n  ),\n\n  Sequence.create(\n    AgentB.doOtherProcessing())\n  )\n);
\n
\n

Messages cannot be passed between sequence runs

\nAll message passing and receiving needs to be done within a single sequence run. (This does not apply to sequences that are composed of other sequences, messages will be passed between sequences called from inside another sequence.)\n
\n

Message passing (Java)

\n
//Message will be passed from AgentA to AgentB\nrun (\n  Sequence.create(\n    Sequence.create(AgentA.sendMessageAction()),\n    Sequence.create(AgentB.recieveMessageAction())\n  ),\n\n  //Message will NOT be passed from AgentA to AgentB\n  Sequence.create(\n    AgentA.sendMessageAction())\n  ),\n\n  Sequence.create(\n    AgentB.recieveMessageAction())\n  )\n);
\n

Executing Action in Parallel

\n

In all the sequences we have shown until now, the actions happen one after the next, like in the following diagram.

\n

\n \n \n \n \n \n \n \n \n \n \n \n \n \n

\n

It is also possible to have two actions happening at the same time, as in the diagram below. Here, AgentA can send a message that both AgentB and AgentC receive and process at the same time. They can then both send a message to AgentA to process.

\n

\n \n \n \n \n \n \n \n \n \n \n \n \n \n

\n

Put the actions that need to happen in parallel in a split.

\n
\nAs for other sequence runs, message cannot be passed between splits.\n
\n

Split (Java)

\n
run (\n    AgentA.doAction1(),\n    Split.create(\n      AgentB.doAction1(),\n      AgentC.doAction1()\n    ),\n    AgentA.doAction2())\n);
\n

It is also possible to want to do several actions in parallel, or sequences of their own in parallel.

\n

\n \n \n \n \n \n \n \n \n \n \n \n \n \n

\n

Multi-Split(Java)

\n
run (\n    AgentA.doAction1(),\n    Split.create(\n      AgentB.doAction1(),\n      Sequence.create(\n        AgentC.doAction1(),\n        AgentB.doAction2()\n      )\n    ),\n    AgentA.doAction2())\n);
\n

The sequence on which actions will be processed in this case is

\n
    \n
  1. AgentA process action1,
    2. \n
  2. AgentB and AgentC process action1
    3. \n
  3. AgentB process action2
    4. \n
  4. AgentA process action2 (having received messages from both AgentB and AgentC)
    5. \n
\n
\nIn all the examples above, doAction includes sending a message to the next agent in the sequence\n
\n
\n

Best Practice

\nIn cases where there are sequences inside splits, or splits inside splits, the model will be a lot easier to work with if sequences and splits were created as variables\n
\n

(Java)

\n
// nested sequence removed and created as a variable\nprivate Sequence agentCActions =\n  Sequence.create(\n    \tAgentC.doAction1(),\n      AgentB.doAction2()\n    )\n\n// main sequence is now easier to read\nrun (\n  Sequence.create(\n    AgentA.doAction1(),\n    Split.create(\n      AgentB.doAction1(),\n      agentCActions\n    ),\n    AgentA.doAction2())\n  )\n);
\n

It is possible to compose sequences and actions to create the complex sequences as needed. Example of more complex sequence - with a sequence inside a sequence.

\n

\n \n \n \n \n

\n

With this you can easily setup a model flow that will make for a more readable and understandable sequencing of actions as demonstrated below.

\n

Complex Time Control (Java)

\n
@Override\npublic void step() {\n\tsuper.step();\n\t\n\tfirstStep(\n\t\tAgentA.startupAction(), \n\t\tAgentB.startupAction()\n\t);\n\t\n\tkickOff(\n\t\tAgentA.kickOffAction(), \n\t\tAgentB.kickOffAction()\n\t);\n\t\n\trun(\n\t\tAgentA.sendMessageAction(), \n\t\tAgentB.recieveMessageAction()\n\t);\n\t\n\tlastStep(\n\t\tAgentA.finalAction(), \n\t\tAgentB.finalAction()\n\t);\n}\n\n@Override\npublic void done() {\n\tsuper.done();\n\t...\n\t// execute Java code here\n\t...\n}
\n

While first/last and set kickoff times are made available, you are also able to get the current tick and write any additional checks during a standard run() action if your model has additional actions that require a specific timing.

","headings":[{"value":"Executing Action in Sequences","depth":2},{"value":"Executing Action in Parallel","depth":2},{"value":"Executing Actions and Code at Set Times","depth":2}],"frontmatter":{"title":"Actions & Sequencing","toc":null,"experimental":null}},"site":{"siteMetadata":{"title":"Simudyne Docs","latestVersion":"2.6"}}},"pageContext":{"absolutePath":"/home/vsts/work/1/s/content/2.6/reference/modelling/actions.md","versioned":false,"version":"2.6","kind":"reference","pagePath":"/reference/modelling/actions","chronology":{"prev":{"name":"Determinism","path":"/reference/modelling/determinism"},"next":{"name":"Messaging","path":"/reference/modelling/messaging"}},"lastUpdated":"2026-04-21T13:56:54.869Z"}}