Mandatory actions #466

antoniojbm · 2023-07-31T13:52:48Z

antoniojbm
Jul 31, 2023

Hi,

I have a question regarding the library, I am trying to solve a problem where I need a mandatory intermediate step. I have an object that can go from point A to point B and from point A to point C, the object when it goes to point C when it is not full and if it is full it should go to point B and wait. The planner understands that going to point B is inefficient and waits at point A. Is there any way to force it to go through point B before going to point C?

Answered by Framba-Luca

Aug 7, 2023

Hi @antoniojbm

A possible solution that comes to my mind is to model the concept of "you want to free pos0 as soon as possible". Maybe @hstairs or @mikand can propose other/better solutions.

So, here is the code I did, slightly modified, that implements this solution.

This is done by:

creating a fluent that says if pos0 is empty (decreasing it every time a vessel leaves pos0).
creating an accumulator, that increases on every action, if pos0 is not empty.
setting in the goals that the accumulator must be <= than the number of vessels +1 (so the barge can move to Delta, and all the vessels can leave the initial zone).

I also removed all the part that were not necessary for the planning an…

View full answer

mikand · 2023-07-31T14:56:23Z

mikand
Jul 31, 2023
Maintainer

Hi @antoniojbm !

one common way of "forcing" a specific behavior is to add a Boolean fluent (or multiple fluents) recording the interesting parts of the plan (in your example, visit B) and force it in the goal (e.g. goal = "be in C" and "if you are empty, you visited B").

If you post your model I can be more concrete.

1 reply

antoniojbm Aug 1, 2023
Author

It is a good idea but in my case there are objects that will go from point A to point B and objects that go from point A to point C without going through B. If I see that there is no way I will try to use that solution because it is the closest to what I need.

I have prepared a picture to make it clear, object B goes from the initial zone to the danger zone, object A must go to the waiting zone because the danger zone is full. The planner leaves object A in the initial zone and does not pass through the waiting zone and I need that if the danger zone is full it waits in the waiting zone.

antoniojbm · 2023-08-04T10:39:20Z

antoniojbm
Aug 4, 2023
Author

I have been working on the problem and I think I have a way but I need to know if you can use "if" in the effects of an action.

5 replies

Framba-Luca Aug 4, 2023
Collaborator

Hi @antoniojbm !

Yes, when you add an effect to an action, you can specify a condition. The effect will be applied ONLY if the condition holds; to add the else counterpart, just add the desired effect with a Not(condition).

More info here.

If the there are no planners that can solve the problem, remember that conditional effects can be removed using a compiler (example here).

If it's not a problem, you can send the unified_planning code that you are using to model this problem: it might be easier to help (and also helps us to see how people are using the library, it's an incredibly valuable feedback :).

antoniojbm Aug 7, 2023
Author

I have tried to do it with conditionals in the effects but I have not achieved much, I really need that if the delta zone is full, the other ships pass to the waiting zone obligatorily. The thing is that it ignores the waiting zone.

import unified_planning
from unified_planning.shortcuts import *



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)
isNotFueled = unified_planning.model.Fluent('IsNotFueled', BoolType(), v=Vessel)
next = unified_planning.model.Fluent('next', BoolType(), p0=Position, p1=Position)
isDelta = unified_planning.model.Fluent('isDelta', BoolType(), p=Position)
isNotDelta = unified_planning.model.Fluent('isNotDelta', BoolType(), p=Position)
capacity = unified_planning.model.Fluent('capacity', IntType(), p=Position)
isWaiting = unified_planning.model.Fluent('isWaiting', BoolType(), v=Vessel)
isNotWaiting = unified_planning.model.Fluent('isNotWaiting', BoolType(), v=Vessel)
isWaitingZone = unified_planning.model.Fluent('isWaitingZone', BoolType(), p=Position)
isNotWaitingZone = unified_planning.model.Fluent('isNotWaitingZone', BoolType(), p=Position)

# Define Actions

    # vessel_go_to
vessel_go_to = InstantaneousAction('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.add_precondition(vessel_on(v, p0))
vessel_go_to.add_precondition(next(p0, p1))
vessel_go_to.add_precondition(GT(capacity(p1),0))
vessel_go_to.add_precondition(isWaitingZone(p0))
vessel_go_to.add_effect(vessel_on(v, p1), True)
vessel_go_to.add_effect(vessel_on(v, p0), False)
vessel_go_to.add_decrease_effect(capacity(p1), 1)
vessel_go_to.add_increase_effect(capacity(p0), 1)

    # vessel_go_to_delta
vessel_go_to_delta = InstantaneousAction('vessel_go_to_delta', v=Vessel, p0=Position, p1=Position)
v = vessel_go_to_delta.parameter('v')
p0 = vessel_go_to_delta.parameter('p0')
p1 = vessel_go_to_delta.parameter('p1')
vessel_go_to_delta.add_precondition(vessel_on(v, p0))
vessel_go_to_delta.add_precondition(next(p0, p1))
vessel_go_to_delta.add_precondition(isDelta(p1))
vessel_go_to_delta.add_precondition(isNotWaiting(v))

vessel_go_to_delta.add_effect(vessel_on(v, p1), True,  GT(capacity(p1),0))
vessel_go_to_delta.add_effect(vessel_on(v, p0), False,  GT(capacity(p1),0))
vessel_go_to_delta.add_decrease_effect(capacity(p1), 1,  GT(capacity(p1),0))
vessel_go_to_delta.add_increase_effect(capacity(p0), 1,  GT(capacity(p1),0))

vessel_go_to_delta.add_effect(isWaiting(v), True,  LT(capacity(p1),1))


    # vessel-exit-delta
verge_exit_delta = InstantaneousAction('vessel-exit-delta', v=Vessel, p0=Position, p1=Position)
v = verge_exit_delta.parameter('v')
p0 = verge_exit_delta.parameter('p0')
p1 = verge_exit_delta.parameter('p1')
verge_exit_delta.add_precondition(vessel_on(v, p0))
verge_exit_delta.add_precondition(next(p0, p1))
verge_exit_delta.add_precondition(GT(capacity(p1),0))
verge_exit_delta.add_precondition(isDelta(p0))
verge_exit_delta.add_effect(vessel_on(v, p1), True)
verge_exit_delta.add_effect(vessel_on(v, p0), False)
verge_exit_delta.add_decrease_effect(capacity(p1), 1)
verge_exit_delta.add_increase_effect(capacity(p0), 1)




    # barge_go_to
barge_go_to = InstantaneousAction('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.add_precondition(barge_on(b, p0))
barge_go_to.add_precondition(next(p0, p1))
barge_go_to.add_precondition(GT(capacity(p1),0))
barge_go_to.add_effect(barge_on(b, p1), True)
barge_go_to.add_effect(barge_on(b, p0), False)
barge_go_to.add_decrease_effect(capacity(p1), 1)



    # bunkering
bunkering = InstantaneousAction('bunkering', v=Vessel, b=Barge, p=Position)
v = bunkering.parameter('v')
b = bunkering.parameter('b')
p = bunkering.parameter('p')
bunkering.add_precondition(vessel_on(v, p))
bunkering.add_precondition(isNotFueled(v))
bunkering.add_precondition(barge_on(b, p))
bunkering.add_precondition(isDelta(p))
bunkering.add_effect(isFueled(v), True)
bunkering.add_effect(isNotFueled(v), False)




# 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(isNotFueled, default_initial_value=True)
problem.add_fluent(next, default_initial_value=False)
problem.add_fluent(isDelta, default_initial_value=False)
problem.add_fluent(isNotDelta, default_initial_value=True)
problem.add_fluent(capacity, default_initial_value=0)

problem.add_fluent(isWaiting, default_initial_value=False)
problem.add_fluent(isNotWaiting, default_initial_value=True)
problem.add_fluent(isWaitingZone, default_initial_value=False)

problem.add_fluent(isNotWaitingZone, default_initial_value=True)



    # Add Actions
problem.add_action(vessel_go_to)
problem.add_action(vessel_go_to_delta)
problem.add_action(verge_exit_delta)

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('Zona de Espera', Position)
pos2 = unified_planning.model.Object('Delta', Position)
pos3 = 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)
problem.add_object(pos3)




    # 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(pos0, pos2), True)
problem.set_initial_value(next(pos2, pos0), True)

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

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

problem.set_initial_value(isDelta(pos2), True)
problem.set_initial_value(isNotDelta(pos2), False)

problem.set_initial_value(isWaitingZone(pos1), True)
problem.set_initial_value(isNotWaitingZone(pos1), False)
    
    
    #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(barge_on(barge1, pos3), 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)

problem.set_initial_value(isNotFueled(vessel1), True)
problem.set_initial_value(isNotFueled(vessel2), True)
problem.set_initial_value(isNotFueled(vessel3), True)


    #Capacidades
problem.set_initial_value(capacity(pos0), 100)
problem.set_initial_value(capacity(pos1), 100)
problem.set_initial_value(capacity(pos2), 2)
problem.set_initial_value(capacity(pos3), 100)



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



#print(problem)

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

Enrico Scala returned: SequentialPlan:
barge_go_to(barge1, Salida, Delta)
vessel_go_to_delta(vessel2, Zona Inicial, Delta)
bunkering(vessel2, barge1, Delta)
vessel-exit-delta(vessel2, Delta, Salida)
vessel_go_to_delta(vessel3, Zona Inicial, Delta)
bunkering(vessel3, barge1, Delta)
vessel-exit-delta(vessel3, Delta, Salida)
vessel_go_to_delta(vessel1, Zona Inicial, Delta)
bunkering(vessel1, barge1, Delta)
vessel-exit-delta(vessel1, Delta, Salida)

Framba-Luca Aug 7, 2023
Collaborator

Hi @antoniojbm

A possible solution that comes to my mind is to model the concept of "you want to free pos0 as soon as possible". Maybe @hstairs or @mikand can propose other/better solutions.

So, here is the code I did, slightly modified, that implements this solution.

This is done by:

creating a fluent that says if pos0 is empty (decreasing it every time a vessel leaves pos0).
creating an accumulator, that increases on every action, if pos0 is not empty.
setting in the goals that the accumulator must be <= than the number of vessels +1 (so the barge can move to Delta, and all the vessels can leave the initial zone).

I also removed all the part that were not necessary for the planning and put the "new code" between some comments tagged with [1], just to see quicker what I added:

import unified_planning
from unified_planning.shortcuts import *

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

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

# [1]
# every action will increase this accumulator if vessels_in_p0 is not 0
accumulator = Fluent('accumulator', IntType())
vessels_in_p0 = Fluent('vessels_in_p0', IntType())
# starting zone needs to be defined before, because it is used in the actions
pos0 = Object('Zona Inicial', Position)
# end [1]

# Define Actions

    # vessel_go_to
vessel_go_to = InstantaneousAction('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.add_precondition(vessel_on(v, p0))
vessel_go_to.add_precondition(next(p0, p1))
vessel_go_to.add_precondition(GT(capacity(p1),0))
vessel_go_to.add_effect(vessel_on(v, p1), True)
vessel_go_to.add_effect(vessel_on(v, p0), False)
vessel_go_to.add_decrease_effect(capacity(p1), 1)
vessel_go_to.add_increase_effect(capacity(p0), 1)

# [1]
# decrease vessels_in_p0 if it is leaving pos0
vessel_go_to.add_decrease_effect(vessels_in_p0, 1, Equals(pos0, p0))
# increase vessels_in_p0 if it is going in pos0
vessel_go_to.add_increase_effect(vessels_in_p0, 1, Equals(pos0, p1))
# end [1]

    # barge_go_to
barge_go_to = InstantaneousAction('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.add_precondition(barge_on(b, p0))
barge_go_to.add_precondition(next(p0, p1))
barge_go_to.add_precondition(GT(capacity(p1),0))
barge_go_to.add_effect(barge_on(b, p1), True)
barge_go_to.add_effect(barge_on(b, p0), False)
barge_go_to.add_decrease_effect(capacity(p1), 1)

    # bunkering
bunkering = InstantaneousAction('bunkering', v=Vessel, b=Barge, p=Position)
v = bunkering.parameter('v')
b = bunkering.parameter('b')
p = bunkering.parameter('p')
bunkering.add_precondition(vessel_on(v, p))
bunkering.add_precondition(Not(isFueled(v)))
bunkering.add_precondition(barge_on(b, p))
bunkering.add_precondition(isDelta(p))
bunkering.add_effect(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(capacity, default_initial_value=0)

    # Add Actions
problem.add_action(vessel_go_to)

problem.add_action(barge_go_to)


problem.add_action(bunkering)

# [1] all actions increase the accumulator if vessels_in_p0 is not 0
for action in problem.actions:
    action.add_increase_effect(accumulator, 1, GT(vessels_in_p0, 0))
# end [1]


    # Add Objects
vessel1 = Object('vessel1', Vessel)
vessel2 = Object('vessel2', Vessel)
vessel3 = Object('vessel3', Vessel)
barge1 = Object('barge1', Barge)
# defined before
# pos0 = Object('Zona Inicial', Position)
pos1 = Object('Zona de Espera', Position)
pos2 = Object('Delta', Position)
pos3 = 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)
problem.add_object(pos3)

    # 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(pos0, pos2), True)
problem.set_initial_value(next(pos2, pos0), True)

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

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

problem.set_initial_value(isDelta(pos2), True)

    #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(barge_on(barge1, pos3), 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)


    #Capacidades
problem.set_initial_value(capacity(pos0), 100)
problem.set_initial_value(capacity(pos1), 100)
problem.set_initial_value(capacity(pos2), 2)
problem.set_initial_value(capacity(pos3), 100)

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

# [1]
problem.add_goal(LE(accumulator, len(tuple(problem.objects(Vessel)))+1))
problem.add_fluent(accumulator, default_initial_value=0)
# assumes all the vessels start in pos0
problem.add_fluent(vessels_in_p0, default_initial_value=len(tuple(problem.objects(Vessel))))
# problem.add_quality_metric(MinimizeExpressionOnFinalState(accumulator))


#print(problem)

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

This prints:

Enrico Scala returned: SequentialPlan:
    barge_go_to(barge1, Salida, Delta)
    vessel_go_to(vessel2, Zona Inicial, Delta)
    vessel_go_to(vessel1, Zona Inicial, Zona de Espera)
    vessel_go_to(vessel3, Zona Inicial, Zona de Espera)
    bunkering(vessel2, barge1, Delta)
    vessel_go_to(vessel2, Delta, Salida)
    vessel_go_to(vessel3, Zona de Espera, Delta)
    bunkering(vessel3, barge1, Delta)
    vessel_go_to(vessel3, Delta, Salida)
    vessel_go_to(vessel1, Zona de Espera, Delta)
    bunkering(vessel1, barge1, Delta)
    vessel_go_to(vessel1, Delta, Salida)

Small Notes:

there is no reason to define a fluent called isNotDelta. Simply use Not(isDelta).
there is also no need to define vessel_go_to and vessel_go_to_delta. Let the planner decide where he wants to send the ships!

Let me know if this solution works for your use-case!

Answer selected by antoniojbm

antoniojbm Aug 7, 2023
Author

Thank you very much, you guys are amazing, that's what I was looking for, although I have modified a couple of things, the vessels can start in the waiting area too so I have changed the initial value of vessels_in_p0 to a literal, and the barges can be more than one so I guess I would have to change the +1 of the goal of the accumulator, I have made the changes and it works perfectly too. Also thank you very much for the corrections, I'm just learning this and I don't have much idea about it yet.

Framba-Luca Aug 7, 2023
Collaborator

Yes, you did the right corrections! Happy it helped 😄

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Mandatory actions #466

{{title}}

Replies: 2 comments 6 replies

{{title}}

{{title}}

{{editor}}'s edit

{{editor}}'s edit

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

Select a reply

Mandatory actions #466

antoniojbm Jul 31, 2023

Replies: 2 comments · 6 replies

mikand Jul 31, 2023 Maintainer

antoniojbm Aug 1, 2023 Author

antoniojbm Aug 4, 2023 Author

Framba-Luca Aug 4, 2023 Collaborator

antoniojbm Aug 7, 2023 Author

Framba-Luca Aug 7, 2023 Collaborator

antoniojbm Aug 7, 2023 Author

Framba-Luca Aug 7, 2023 Collaborator

antoniojbm
Jul 31, 2023

Replies: 2 comments 6 replies

mikand
Jul 31, 2023
Maintainer

antoniojbm Aug 1, 2023
Author

antoniojbm
Aug 4, 2023
Author

Framba-Luca Aug 4, 2023
Collaborator

antoniojbm Aug 7, 2023
Author

Framba-Luca Aug 7, 2023
Collaborator

antoniojbm Aug 7, 2023
Author

Framba-Luca Aug 7, 2023
Collaborator