Timed Simulator

[karpase]

Hi @Framba-Luca and @mikand ,
I saw that there's an old (and possibly abandoned) branch called timed-simulator, with something that can simulate a temporal plan.
Would that still work? Or is there some other way to simulator the execution of a temporal plan?

Thanks,
Erez.

[mikand]

Hi @karpase!

We definitely would like to have a temporal simulator, but we got stuck on the interface for such a simulator.
(Note that we have a plan validator for time-triggered plans (see https://github.com/aiplan4eu/unified-planning/blob/master/unified_planning/engines/plan_validator.py#L211) that essentially performs a simulation of the plan)

I had in mid a more "interactive" interface where the user can evolve the system along different directions by specifying the actions to perform.

The issue I have is what the user must specify for this simulation, TAMER has an interface that allows to only specify the sequence of events/happenings and then computes the time using an STN, but I am unsure this is a general enough interface.

Lifting TAMER interface, it would be something like:

with TimedSimulator(problem) as sim:
    initial_state = sim.get_initial_state()
    a_started = sim.apply_event(initial_state, a, START) #construct the state where A is strted, but on ended yet
    a_ended = sim.apply_event(a_started, a, END) #finish A
    ab_started = sim.apply_event(a_started, b, START) #construct a state where B is started after A is started, but neither is terminated yet
    ...

Inside every state there is an STN checking that the total order sequence of event is schedulable.

Do you have any idea? What would be a convenient interface for your use-cases?

[karpase]

Thanks @mikand
I'll take a look at the plan validator, it looks like a good starting point.

What I want to do is probably not very general, but it's to perform concurrent planning and execution. Essentially the idea is to call an external process which runs and sometimes outputs things like "DISPATCH action a", and then I want to simulate the effects of executing a (which is a durative action, so we need to keep track of the end effect of a).

Then, to make things more complicated, I want to sometimes change the goal, which involves restarting the planner but keeping the same state of the world (and pending end actions).

I'll let you know if anything useful comes out of this.

Thanks,
Erez.

[mikand]

PS: another idea was to consider explicit time elapse, so ask the user to decide when and by how much time is allowed to elapse.

[karpase]

Looks like for what I need, this is the interface that works.

class TimeTriggeredSimulator:
  def commit_to_dispatch(start_time, action_instance, duration):
  # commits to dispatch the given action_instance at the given start time with the given duration

  def advance_time(delta_time):
  # advances simulated time, executing events which occur in the time interval

It looks like I can just take the existing TimeTriggeredValidator, split the functions a little differently, and get this functionality.
This can also be used to implement different STN dispatching strategies, although it does assume that an action duration is determined at it start.

@mikand - what do you think?

Cheers,
Erez.

[mikand]

This is quite similar to what I had in mind in my PS. Indeed, I think you should be able to re-use a good portion of the TimeTriggeredValidator code. If you want, we can then incapsulate this as an engine of the UP (definining a new OperationMode), I think this is quite useful in general.

@arbimo @alvalentini