Durative Action

[antoniojbm]

Hi, I have been trying to use DurativeAction for some time and I don't understand what it is for. My intention is that some ships have arrival time and bunkering times, from here the problems arise. It seems to work well but:

As you can see in the photo, if the left part is the start time of the action, why the bunkering is not adding that time? What am I doing wrong?

My second question is: What can I do with this? Can I optimize according to these times so that the scheduler always prioritizes the shortest ship time? For example, if there are two ships v1 takes 30 minutes to arrive and 15 minutes to bunkering, v2 takes 15 minutes to arrive and 15 minutes to bunkering, how can I make it take into account those times and take out first the ship that has taken less time?

My code is:

import unified_planning
from unified_planning.shortcuts import *




# Variables PPDL

Vessel = UserType('Vessel')
Barge = UserType('Barge')
Position = UserType('Position')




# Define Fluents
vessel_on = unified_planning.model.Fluent('vessel-on', BoolType(), v=Vessel, p=Position)
barge_on = unified_planning.model.Fluent('barge-on', BoolType(), b=Barge, p=Position)
isFueled = unified_planning.model.Fluent('isFueled', BoolType(), v=Vessel)
next = unified_planning.model.Fluent('next', BoolType(), p0=Position, p1=Position)
isDelta = unified_planning.model.Fluent('isDelta', BoolType(), p=Position)
arrivalTime = unified_planning.model.Fluent('arrivalTime', IntType(), v=Vessel)
bunkeringTime = unified_planning.model.Fluent('bunkeringTime', IntType(), v=Vessel)
exitTime = unified_planning.model.Fluent('exitTime', IntType(), v=Vessel)
capacity = unified_planning.model.Fluent('capacity', IntType(), p=Position)




    # vessel_go_to
vessel_go_to = DurativeAction('vessel_go_to', v=Vessel, p0=Position, p1=Position)
v = vessel_go_to.parameter('v')
p0 = vessel_go_to.parameter('p0')
p1 = vessel_go_to.parameter('p1')
vessel_go_to.set_fixed_duration(arrivalTime(v))
vessel_go_to.add_condition(StartTiming(), vessel_on(v, p0))
vessel_go_to.add_condition(StartTiming(), next(p0, p1))
vessel_go_to.add_effect(EndTiming(), vessel_on(v, p1), True)
vessel_go_to.add_effect(EndTiming(), vessel_on(v, p0), False)


vessel_go_to.add_condition(StartTiming(), GT(capacity(p1), 0))

vessel_go_to.add_effect(EndTiming(), capacity(p1), capacity(p1) - 1)
vessel_go_to.add_effect(EndTiming(), capacity(p0),capacity(p0) + 1)



    # barge_go_to
barge_go_to = DurativeAction('barge_go_to', b=Barge, p0=Position, p1=Position)
b = barge_go_to.parameter('b')
p0 = barge_go_to.parameter('p0')
p1 = barge_go_to.parameter('p1')
barge_go_to.set_fixed_duration(20)
barge_go_to.add_condition(EndTiming(), barge_on(b, p0))
barge_go_to.add_condition(EndTiming(), next(p0, p1))
barge_go_to.add_effect(EndTiming(), barge_on(b, p1), True)
barge_go_to.add_effect(EndTiming(), barge_on(b, p0), False)



    # bunkering
bunkering = DurativeAction('bunkering', v=Vessel, b=Barge, p=Position)
v = bunkering.parameter('v')
b = bunkering.parameter('b')
p = bunkering.parameter('p')
bunkering.set_fixed_duration(bunkeringTime(v))
bunkering.add_condition(StartTiming(), vessel_on(v, p))
bunkering.add_condition(StartTiming(), Not(isFueled(v)))
bunkering.add_condition(StartTiming(), barge_on(b, p))
bunkering.add_condition(StartTiming(), isDelta(p))
bunkering.add_effect(EndTiming(), isFueled(v), True)



# Define Problem
problem = Problem('problemBunkering')

    # Add Fluents
problem.add_fluent(vessel_on, default_initial_value=False)
problem.add_fluent(barge_on, default_initial_value=False)
problem.add_fluent(isFueled, default_initial_value=False)
problem.add_fluent(next, default_initial_value=False)
problem.add_fluent(isDelta, default_initial_value=False)
problem.add_fluent(arrivalTime, default_initial_value=0)
problem.add_fluent(bunkeringTime, default_initial_value=0)
problem.add_fluent(exitTime, default_initial_value=0)
problem.add_fluent(capacity, default_initial_value=0)




    # Add Actions
problem.add_action(vessel_go_to)

problem.add_action(barge_go_to)

problem.add_action(bunkering)





    # Add Objects
vessel1 = unified_planning.model.Object('vessel1', Vessel)
vessel2 = unified_planning.model.Object('vessel2', Vessel)
vessel3 = unified_planning.model.Object('vessel3', Vessel)
barge1 = unified_planning.model.Object('barge1', Barge)
pos0 = unified_planning.model.Object('Zona Inicial', Position)
pos1 = unified_planning.model.Object('Delta', Position)
pos2 = unified_planning.model.Object('Salida', Position)





problem.add_object(vessel1)
problem.add_object(vessel2)
problem.add_object(vessel3)
problem.add_object(barge1)
problem.add_object(pos0)
problem.add_object(pos1)
problem.add_object(pos2)




    # Define Initial state
    
    #Tablero inicial
problem.set_initial_value(next(pos0, pos1), True)
problem.set_initial_value(next(pos1, pos0), True)

problem.set_initial_value(next(pos1, pos2), True)
problem.set_initial_value(next(pos2, pos1), True)

problem.set_initial_value(isDelta(pos1), True)
    
    
problem.set_initial_value(capacity(pos0), 100)
problem.set_initial_value(capacity(pos1), 2)
problem.set_initial_value(capacity(pos2), 100)
    
    
    #Posiciones
problem.set_initial_value(vessel_on(vessel1, pos0), True)
problem.set_initial_value(vessel_on(vessel2, pos0), True)
problem.set_initial_value(vessel_on(vessel3, pos0), True)



problem.set_initial_value(arrivalTime(vessel1), 8)
problem.set_initial_value(arrivalTime(vessel2), 32)
problem.set_initial_value(arrivalTime(vessel3), 10)

problem.set_initial_value(bunkeringTime(vessel1), 2)
problem.set_initial_value(bunkeringTime(vessel2), 14)
problem.set_initial_value(bunkeringTime(vessel3), 12)



problem.set_initial_value(barge_on(barge1, pos2), True)


    #Condiciones de los vessels
problem.set_initial_value(isFueled(vessel1), False)
problem.set_initial_value(isFueled(vessel2), False)
problem.set_initial_value(isFueled(vessel3), False)


    # Add Goal
problem.add_goal(isFueled(vessel1))
problem.add_goal(isFueled(vessel2))
problem.add_goal(isFueled(vessel3))
problem.add_goal(vessel_on(vessel1, pos2))
problem.add_goal(vessel_on(vessel2, pos2))
problem.add_goal(vessel_on(vessel3, pos2))



# print(problem)

# Solve Problem with OneshotPlanner
# Enhsp
with OneshotPlanner(name='tamer') as planner:
    result = planner.solve(problem)
    
    if result.status == up.engines.PlanGenerationResultStatus.SOLVED_SATISFICING:
        print("Tamer returned: %s" % result.plan)
    else:
        print("No plan found.")

[Framba-Luca]

Hi @antoniojbm

So, for your first point, you are not telling the planner that bunkering is mutually exclusive.

You need a boolean fluent that says "barge_1 is currently bunkering a vessel, therefore it can't bunker another one".

Here a code example that adds the is_bunkering fluent that models this concept:

is_bunkering = Fluent("is_bunkering", b=Barge)
    # bunkering
bunkering = DurativeAction('bunkering', v=Vessel, b=Barge, p=Position)
v = bunkering.parameter('v')
b = bunkering.parameter('b')
p = bunkering.parameter('p')
bunkering.set_fixed_duration(bunkeringTime(v))
bunkering.add_condition(StartTiming(), Not(is_bunkering(b))) # <- new condition
bunkering.add_condition(StartTiming(), vessel_on(v, p))
bunkering.add_condition(StartTiming(), Not(isFueled(v)))
bunkering.add_condition(StartTiming(), barge_on(b, p))
bunkering.add_condition(StartTiming(), isDelta(p))
bunkering.add_effect(EndTiming(), isFueled(v), True)
# Extra effects
bunkering.add_effect(StartTiming(), is_bunkering(b), True)
bunkering.add_effect(EndTiming(), is_bunkering(b), False)

Adding this you should get the expected result. (you also have to add the is_bunkering fluent to the problem with default_initial_value = False).

For the second part: what can you do with that? Currently we don't have any planner that gives temporal optimality guarantees.

So, you can get a valid plan without any guarantees about the quality.

[antoniojbm]

Hi @Framba-Luca,

First of all, thanks for always answering and trying to help me, it is amazing how well you explain. Secondly, I have added what you told me is going better but it still doesn't add up sometimes the bunkering time, maybe I'm not understanding well how the time is shown in the TimeTriggeredPlan, basically what appears on the left is the time when each action starts, isn't it? But what are the decimals for example 20.01?

The third thing, my intention is to make a planning of ships that do bunkering where it takes into account the times of arrival, bunkering realization, departure, etc, ie, to optimize in terms of total time actions for example if two vessels have arrival time 10 and 30 that the planner would arrive first to the vessel that has those 10 minutes of arrival, but I can not find any information to help me, I've been trying about a month and a half, I'm pretty blocked at this point.

If you think it is not possible let me know because I am a bit desperate.

[Framba-Luca]

Did you also change something in the vessel_go_to?

The decimals appear because the epsilon of the planner is 0.01 seconds, you can see it as the time needed to "notice" the state change, so "barge_go_to" finishes at time 20, the bunkering can start at 20.01 (at the instant 20, the fluent barge_on(barge1, Salida) still evaluates as False, at instant 20.01 it evaluates as True).

Sadly for temporal problems at the moment we have no engines that guarantees any kind of optimality.

[antoniojbm]

The last question, and without using temporary planning, would there be any way to optimize for example by distance transforming the minutes in meters, that a v1 that is 20m away, arrives before one that is 40m away, would it be possible to optimize according to that distance so that v1 arrives first?