statechart | Statechart implementation in JavaScript

There are basically two approaches.

The first approach is to define an explicit reference from the child statechart to the parent. Like you did for the parent.

I'm guessing Simulation extends from ExperimentParamVariation. The key to achieve what you want would be to determine when the experiment has ended.

The documentation shows some interesting methods like getProgress() and getState(), but you would have to poll those methods until the progress is 1 or the state is FINISHED or ERROR. There are also the methods onAfterExperiment() and onError() that should be called by the engine to indicate that the experiment has ended or there was an error. I think you could use these last two methods with a Semaphore to control how many experiments run at once:

To be able to access a block in main from an Agent Type, you need to have a population of that type in main, even if empty. Drag and drop the "Agent" element from the Agent palette to main, choose the type that is trying to access main and make it initially empty. After that, if you run again, main should become accessible.

deleteSelf is really a low-level internal function that you shouldn't typically need to explicitly call yourself. It just removes them from their population and has no 'synchronisation' with the process flow (i.e., it doesn't also remove them from the process flow); all process flows expect the agents therein to exist in a population throughout their process lifecycle, hence you get the error you mentioned if you try to remove them from their population whilst they're in a flow.

In general for process flows, you should delete agents in one via the standard mechanism for all process flows: flowing into a sink block. (And use exit blocks if you want them to leave the flow but remain in existence.)

In the Pedestrian library case, use the built-in cancel ports (as you were attempting) and send them to a PedSink block from these ports.

(If you had other possible reasons to cancel peds from blocks that's fine; you just have conditional logic in the cancel flow to do whatever is needed depending on why you had to cancel them, which might mean storing the cancellation reason in the ped agent...)

AnyLogic libraries also allow you to remove agents from the process using the remove function of blocks, which I think exists for all blocks in all libraries that an agent could spend time in (and thus it make sense to remove them from). But then, if you want to delete them, you have to handle that part explicitly yourself:

• If the pedestrians had been added to the (hidden) default population via a PedSource block, then here you would have to use deleteSelf.

• If the pedestrians had been added to the process via a PedEnter, or the PedSource had been set to add them to a custom population (which is a common thing to do so your ped agents exist in a single named population), you'd delete them via the standard remove_ function created by AnyLogic when you define a population --- see the AnyLogic Help > Agent Based Modeling > Adding and removing agents from population dynamically help page.

Note that using a sink block also visually represent the 'remove and delete' possibility (and logic) in the process flow which is better IMO.

NB: Having said this, only the Pedestrian library has this special universal cancel-from-blocks-into-a-special-visual-flow mechanism so, when using process flows from other libraries (e.g., the standard Process Modeling Library), it may be more convenient to use remove if the need to remove them (and delete them or not) is determined by logic outside the process flow (such as in agent statecharts).

This is doable using the function you are trying to use, but that function is effectively complex internal (undocumented) AnyLogic code relating to how agents move across networks 'under the covers' (when asked to do so via blocks or moveTo function calls). I wouldn't want to guarantee that this will stay the same in future releases (and requires a good understanding of Java).

(Agents in GIS space have a distanceByRoute function to get the distance via the GIS space to another agent, but there is no equivalent for agents in networks I am aware of. Typically, though, you don't need to use the distance-by-path, so what exactly is your reason for needing it? Even where you do, it may often be good enough just to use the straight-line distance, which you can get via the getDistance functions in agents, not the getDistance functions for a network.)

That said, this can work as below...

The getDistance function (Java method) you are trying to call only exists on a Network object (where the network is the 'parent' of all the nodes and paths in a connected network). Plus you have to create (instantiate) Point objects (there is no Point function) and get the ShortestPathData for the network and from/to points in question. (This shortest-path-data represents the calculated route between two points, and you can then get the distance between any set of points on that route.)

So you'd have code something like the below, where agent1 and agent2 are references to your two agents in question, and network is the nodes/paths network (assuming this code is in the agent that contains this network):

Unless you're removing agents in racks via a RackPick block, you aren't actually removing them from the rack system (even if the agent is moving 'past' the RackStore block in the process flow). So your process would need to be something like:

• There is a Wait block following the RackStore (which holds them in the process until required).
• When the "person arrives at the agent location" (your trigger for removing the agent from the rack, though it's not clear what this means --- what is the "agent location" since it's in a rack?), you free them from the Wait block.
• The Wait block is followed by a RackPick block which will remove them from the rack.
• The removed agent carries on in whatever the follow-on flow is (which might just be a Sink in your case).

NB: Also, part of the functionality of RackStore and RackPick blocks is to use resource agents to move to the rack and deposit/retrieve the agent, so it's likely you don't need a "person agent" to be explicitly moving to the agent location (outside of these blocks), though that depends on the exact specification of what you want your model to do.

If you want to use agent inheritance, then you would need to have 2 different populations. A population of type Machine will have agents of type Machine, not their child agent types. I typically deal with this by having the populations for the child agents, and then storing all agents in a list (i.e., array list - allMachines).

You mention different state charts, which is a good reason to use inheritance. Many people will try to inherit because one delay block takes X minutes, while another is Y. In those cases, just parametrize your one agent type. If the logical differences between these machines is small, I would consider just 1 class, with a few extra decides/branches to get the behavior you want. It can sometimes be tricky in AL to have process blocks/visual elements in a parent connect to areas in a child - not impossible, but not as easy as pure Java code where you can override and call super.function().

try this maybe?

access an agent which is in a Delay block or peferrably

use the keyword agent. These keywords differ for different library blocks so best start learning about the lightbulb and how it can help, see here.

acces the specific agent which triggered the 'on enter' action of the delay block?

When you write agent. in the "On enter" block, every agent coming through will execute that code, so by definition, it is always the specific agent :)

My ultimate goal is to open or close a valve object on the agent frame So can I/ how do I A. open or close the valve on the agent frame directly form the main/root frame (on which the Delay block is located) or if that is not possible B. send a message or trigger a statechart within the specific agent which will then open or close the valve from the agent's own frame?

this is something completely different to your original question and just... messy. Please limit questions to 1 topic so it is easy for us to answer :) (see this guide for more)