Vessels with waiting times of other vessels

[antoniojbm]

Hello, I have a question that I have been trying to solve for two weeks, I have a scenario with 4 points (an initial zone, a waiting zone, a delta zone, and an exit), in it there are vessels and barges that will perform a bunkering process in the delta zone. The vessels that arrive first go to the delta zone to perform the bunkering and when it is full, the others go to the waiting zone. In that waiting area the Vessels should take into account the time that other vessels, before it, take to perform the bunkering process but only while it is in the waiting area and add it as waiting time to the total time, how could I do this? Or at least, where can I find documentation regarding this subject, I am quite blocked with this.

import tkinter as tk
from tkinter import ttk
from tkinter import filedialog as fd
from tkinter.messagebox import showinfo
import csv
import unified_planning
from unified_planning.shortcuts import *
from unified_planning.plans import SequentialPlan, ActionInstance


#Clase Data
class Data:
    def __init__(self ,iD, start_time, end_time, deltaAnch_Capacity,
                 deltaAnch_lenghtCapacity, waitPoint_Capacity):
        self.iD = iD
        self.start_time = start_time
        self.end_time = end_time
        self.deltaAnch_Capacity = deltaAnch_Capacity
        self.deltaAnch_lenghtCapacity = deltaAnch_lenghtCapacity        
        self.waitPoint_Capacity = waitPoint_Capacity

# Clase Vessel
class Vessel:

    def __init__(self, id, name, bunkeringProvider, fuelRequested, bunkeringTime,
                 planningIncluded, timeToAnchorage, timeFromAnchorage,
                 timeToWaitingPoint, timeFromWaitingPoint, startAtAnchorage,
                 timeStartAtAnchorage):
        self.id = id
        self.name = name
        self.bunkeringProvider = bunkeringProvider
        self.fuelRequested = fuelRequested
        self.bunkeringTime = bunkeringTime
        self.planningIncluded = planningIncluded
        self.timeToAnchorage = timeToAnchorage
        self.timeFromAnchorage = timeFromAnchorage
        self.timeToWaitingPoint = timeToWaitingPoint
        self.timeFromWaitingPoint = timeFromWaitingPoint
        self.startAtAnchorage = startAtAnchorage
        self.timeStartAtAnchorage = timeStartAtAnchorage
        
#Clase Gabarra
class Barge:
    def __init__(self, id,name, available, companyLegalCode, refuelingPoint,
                 timeToRefueling, fuelCapacity, fuelAvailable,
                 baseStations, locationStartTime, timeInsideAnchorage):
        self.id = id
        self.name = name
        self.available = available
        self.companyLegalCode = companyLegalCode
        self.refuelingPoint = refuelingPoint
        self.timeToRefueling = timeToRefueling
        self.fuelCapacity = fuelCapacity
        self.fuelAvailable = fuelAvailable
        self.baseStations = baseStations
        self.locationStartTime = locationStartTime
        self.timeInsideAnchorage = timeInsideAnchorage
        
        #Clase Inactividad Gabarras 
class BargeInactivityPeriod:
    def __init__(self ,inact_ID, bargeID, inact_timeStart, inact_Duration,
                 inact_BargeEndLocation):
        self.inact_ID = inact_ID
        self.bargeID = bargeID
        self.inact_timeStart = inact_timeStart
        self.inact_Duration = inact_Duration
        self.inact_BargeEndLocation = inact_BargeEndLocation
        
       



listVessels = []
listBarges = []
listBargesInactivityPeriod = []
listData = []

# create interface
root = tk.Tk()
root.title('Bunkering')
root.resizable(False, False)
root.geometry('420x800')

# ask file Data
filenameData = ""
filetypes = (
        ('Csv', '*.csv'),
        ('All files', '*.*')
    )
filenameData = 'C:/Users/abenitez/Desktop/GeneralData.csv'
# filenameData = fd.askopenfilenames(
#         title='Open files',
#         initialdir='/',
#         filetypes=filetypes)


# ask file Vessels
filenameVessel = ""
filetypes = (
        ('Csv', '*.csv'),
        ('All files', '*.*')
    )
filenameVessel = 'C:/Users/abenitez/Desktop/Vessels.csv'
# filenameVessel = fd.askopenfilenames(
#         title='Open files',
#         initialdir='/',
#         filetypes=filetypes)

# ask file barges
filenameBarge = ""
filetypes = (
        ('Csv', '*.csv'),
        ('All files', '*.*')
    )
filenameBarge = 'C:/Users/abenitez/Desktop/Barges.csv'
# filenameBarge = fd.askopenfilenames(
#         title='Open files',
#         initialdir='/',
#         filetypes=filetypes)


# ask file barges inactivity Period
filenameBargeInactivityPeriod = ""
filetypes = (
        ('Csv', '*.csv'),
        ('All files', '*.*')
    )
filenameBargeInactivityPeriod = 'C:/Users/abenitez/Desktop/BargeInactivityPeriod.csv'
# filenameBargeInactivityPeriod = fd.askopenfilenames(
#         title='Open files',
#         initialdir='/',
#         filetypes=filetypes)



# Read Csv


    #Leer Archivo de Barge Inactivity Period
with open(filenameData) as csv_file:
    csv_reader = csv.reader(csv_file, delimiter=',')
    line_count = 0
    column_count = 0
    for row in csv_reader:
        if line_count == 0:
            for column in row:
                if 'ID' == column:
                    posDID = column_count
                elif 'Start_Time' == column:
                    posDStart_Time = column_count
                elif 'End_Time' == column:
                    posDEnd_Time = column_count
                elif 'DeltaAnchorage_vesselsCapacity' == column:
                    posDDeltaAnch_capacity = column_count
                elif 'DeltaAnchorage_lengthCapacity' == column:
                    posDDeltaAnch_Capacity = column_count
                elif 'VesselWaitingPoint_Capacity' == column:
                    posDWaitingPoint_Capacity = column_count

                column_count += 1
        elif line_count!=0:
            listData.append(Data(row[posDID], row[posDStart_Time], row[posDEnd_Time], 
                                          row[posDDeltaAnch_capacity], row[posDDeltaAnch_Capacity], row[posDWaitingPoint_Capacity]))
        line_count += 1
    
    



    #Leer Archivo de Vessel
with open(filenameVessel) as csv_file:
    csv_reader = csv.reader(csv_file, delimiter=',')
    line_count = 0
    column_count = 0
    for row in csv_reader:
        if line_count == 0:
            for column in row:
                if 'Vessel_ID' == column:
                    posVID = column_count                
                elif 'Vessel_name' == column:
                    posVName = column_count
                elif 'Vessel_bunkeringProvider' == column:
                    posVBunkProvider = column_count
                elif 'Vessel_fuelRequested' == column:
                    posVFuelRequested = column_count
                elif 'Bunkering_time' == column:
                    posVBunkeringTime = column_count
                elif 'Vessel_planningIncluded' == column:
                    posVPlanningIncluded = column_count
                elif 'Vessel_timeToAnchorage' == column:
                    posVTimeToAnch = column_count
                elif 'Vessel_timeFromAnchorage' == column:
                    posVTimeFromAnch = column_count
                elif 'Vessel_timeToWaitingPoint' == column:
                    posVTimeToWP = column_count
                elif 'Vessel_timeFromWaitingPoint' == column:
                    posVTimeFromWP = column_count
                elif 'Vessel_startAtAnchorage' == column:
                    posVStartAtAnch = column_count
                elif 'Vessel_timeStartAtAnchorage' == column:
                    posVTimeStartAtAnch = column_count
                column_count += 1
        elif line_count!=0:
            listVessels.append(Vessel(row[posVID], row[posVName], row[posVBunkProvider], row[posVFuelRequested], row[posVBunkeringTime],
                                          row[posVPlanningIncluded], row[posVTimeToAnch], row[posVTimeFromAnch], row[posVTimeToWP],
                                          row[posVTimeFromWP], row[posVStartAtAnch], row[posVTimeStartAtAnch]))
        line_count += 1
        
    #Leer Archivo de Barge
with open(filenameBarge) as csv_file:
    csv_reader = csv.reader(csv_file, delimiter=',')
    line_count = 0
    column_count = 0
    for row in csv_reader:
        if line_count == 0:
            for column in row:
                if 'Barges_ID' == column:
                    posBID = column_count
                elif 'Barge_name' == column:
                    posBName = column_count
                elif 'Barge_available' == column:
                    posBAvailable = column_count
                elif 'Barge_companyLegalCode' == column:
                    posBCompanyLegalCode = column_count
                elif 'Barge_RefuelingPoint' == column:
                    posBRefuelPoint = column_count
                elif 'Barge_timeToRefueling' == column:
                    posBTimeToRefuel = column_count
                elif 'Barge_fuelCapacity' == column:
                    posBFuelCapacity = column_count
                elif 'Barge_fuelAvailable' == column:
                    posBFuelAvailable = column_count
                elif 'Barge_baseStations' == column:
                    posBBaseStation = column_count
                elif 'Barge_locationStartTime' == column:
                    posBLocationStartTime = column_count
                elif 'Barge_timeInsideAnchorage' == column:
                    posBTimeInsideAnch = column_count

                column_count += 1
        elif line_count!=0:
            listBarges.append(Barge(row[posBID], row[posBName], row[posBAvailable], row[posBCompanyLegalCode], row[posBRefuelPoint],
                                          row[posBTimeToRefuel], row[posBFuelCapacity], row[posBFuelAvailable], row[posBBaseStation],
                                          row[posBLocationStartTime], row[posBTimeInsideAnch]))
        line_count += 1


    #Leer Archivo de Barge Inactivity Period
with open(filenameBargeInactivityPeriod) as csv_file:
    csv_reader = csv.reader(csv_file, delimiter=',')
    line_count = 0
    column_count = 0
    for row in csv_reader:
        if line_count == 0:
            for column in row:
                if 'Inact_ID' == column:
                    posIID = column_count
                elif 'Barge_ID' == column:
                    posIBargeID = column_count
                elif 'Inact_timeStart' == column:
                    posITimeStart = column_count
                elif 'Inact_Duration' == column:
                    posIDuration = column_count
                elif 'Inact_BargeEndLocation' == column:
                    posIBargeEndLocation = column_count
               

                column_count += 1
        elif line_count!=0:
            listBargesInactivityPeriod.append(BargeInactivityPeriod(row[posIID], row[posIBargeID], row[posITimeStart], 
                                          row[posIDuration], row[posIBargeEndLocation]))
        line_count += 1
    
    

    
#Start PDDL

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)
used = Fluent('used', BoolType(), b=Barge)

    # Initial to Waiting
arrTime_init = Fluent('arrTime_init', IntType(), v=Vessel)
# add_Time_init = unified_planning.model.Fluent('add_Time_init', IntType(), v=Vessel)
waitTime = Fluent('waitTime', IntType(), v=Vessel)
# add_Time_Wait = unified_planning.model.Fluent('add_Time_Wait', IntType(), v=Vessel)

    # Waiting to Delta
arrTime_delta = Fluent('arrTime_delta', IntType(), v=Vessel)
# add_Time_delta = unified_planning.model.Fluent('add_Time_delta', IntType(), v=Vessel)
bunkTime = Fluent('bunkTime', IntType(), v=Vessel)
# add_Time_Bunk = unified_planning.model.Fluent('add_Time_Bunk', IntType(), v=Vessel)

    # Delta to Exit
arrTime_exit = Fluent('arrTime_exit', IntType(), v=Vessel)
# add_Time_exit = unified_planning.model.Fluent('add_Time_exit', IntType(), v=Vessel)

totalTime = Fluent('totalTime', IntType(), v=Vessel)
showedVessel = Fluent('showed', BoolType(), v=Vessel)
fuelRequiredVessel = Fluent('fuelRequiredVessel', IntType(), v=Vessel)
totalFuelBarge = Fluent('totalFuelBarge', IntType(), b=Barge)
actualFuelBarge = Fluent('actualFuelBarge', IntType(), b=Barge)

isRefuelZone = Fluent('isRefuelZone', BoolType(), 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
   
    # Add Objects
pos1 = Object('Zona de Espera', Position)
pos2 = Object('Delta', Position)
pos3 = Object('Salida', Position)
pos0 = Object('Zona Inicial', Position)
pos4 = Object('Zona Refueling Barge', Position)
# end [1]

numVesselp0 = 0
for vessel in listVessels:
    if (vessel.planningIncluded == "True"):
        if(vessel.startAtAnchorage == "False"):
            numVesselp0=numVesselp0+1

# Define Actions
    # vessel_go_to_exit
vessel_go_to_exit = InstantaneousAction('vessel_go_to_exit', v=Vessel, p0=Position, p1=Position)
v = vessel_go_to_exit.parameter('v')
p0 = vessel_go_to_exit.parameter('p0')
p1 = vessel_go_to_exit.parameter('p1')

vessel_go_to_exit.add_precondition(vessel_on(v, p0))
vessel_go_to_exit.add_precondition(Equals(pos3, p1))
vessel_go_to_exit.add_precondition(next(p0, p1))
vessel_go_to_exit.add_precondition(isFueled(v))
vessel_go_to_exit.add_precondition(GT(capacity(p1),0))
vessel_go_to_exit.add_effect(vessel_on(v, p1), True)
vessel_go_to_exit.add_effect(vessel_on(v, p0), False)
vessel_go_to_exit.add_decrease_effect(capacity(p1), 1)
vessel_go_to_exit.add_increase_effect(capacity(p0), 1)
vessel_go_to_exit.add_increase_effect(totalTime(v), arrTime_exit(v))

    # 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(Not(Equals(pos3, p1)))
vessel_go_to.add_precondition(GT(capacity(p1),0))
vessel_go_to.add_precondition(Not(isRefuelZone(p1)))
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.add_increase_effect(totalTime(v), arrTime_init(v), Equals(pos1, p1)) 

vessel_go_to.add_increase_effect(totalTime(v), arrTime_delta(v), And(Equals(pos2, p1), Equals(pos1, p0))) 

vessel_go_to.add_increase_effect(totalTime(v), Plus(arrTime_init(v),arrTime_delta(v)), And(Equals(pos2, p1), Equals(pos0, p0)))


    # 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))

    # 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_effect(barge_on(b, p1), True)
barge_go_to.add_effect(barge_on(b, p0), False)

    # 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_precondition(LT(fuelRequiredVessel(v), actualFuelBarge(b)))
bunkering.add_effect(isFueled(v), True)
bunkering.add_effect(used(b), True)
bunkering.add_increase_effect(totalTime(v), bunkTime(v))
bunkering.add_decrease_effect(actualFuelBarge(b), fuelRequiredVessel(v))


    # refueling
refueling = InstantaneousAction('refueling', b=Barge, p=Position)
b = refueling.parameter('b')
p = refueling.parameter('p')
refueling.add_precondition(barge_on(b, p))
refueling.add_precondition(isRefuelZone(p))
refueling.add_effect(actualFuelBarge(b), totalFuelBarge(b))





showTime = InstantaneousAction('showTime', v=Vessel, p=Position)
v = bunkering.parameter('v')
p = bunkering.parameter('p')
showTime.add_precondition(Equals(pos3, p))
showTime.add_precondition(isFueled(v))
showTime.add_effect(showedVessel(v), True)
showTime.add_increase_effect(totalTime(v), 0)



# 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)
problem.add_fluent(used, default_initial_value=False)


problem.add_fluent(arrTime_init, default_initial_value=0)
# problem.add_fluent(add_Time_init, default_initial_value=0)
problem.add_fluent(waitTime, default_initial_value=0)
# problem.add_fluent(add_Time_Wait, default_initial_value=0)

problem.add_fluent(arrTime_delta, default_initial_value=0)
# problem.add_fluent(add_Time_delta, default_initial_value=0)
problem.add_fluent(bunkTime, default_initial_value=0)
# problem.add_fluent(add_Time_Bunk, default_initial_value=0)

problem.add_fluent(arrTime_exit, default_initial_value=0)
# problem.add_fluent(add_Time_exit, default_initial_value=0)

problem.add_fluent(totalTime, default_initial_value=0)


problem.add_fluent(showedVessel, default_initial_value=False)

problem.add_fluent(fuelRequiredVessel, default_initial_value=0)
problem.add_fluent(totalFuelBarge, default_initial_value=0)
problem.add_fluent(actualFuelBarge, default_initial_value=0)


problem.add_fluent(isRefuelZone, default_initial_value=False)




    # Add Actions
problem.add_action(vessel_go_to)

problem.add_action(barge_go_to)


problem.add_action(bunkering)

problem.add_action(showTime)

problem.add_action(refueling)


problem.add_action(vessel_go_to_exit)

for action in problem.actions:
    action.add_increase_effect(accumulator, 1, GT(vessels_in_p0, 0))


# end [1]



# Vessels and Barges data from csv

for vessel in listVessels:
    if (vessel.planningIncluded == "True"):
        aux = Object(vessel.name, Vessel)
        problem.add_object(aux)
        
        #Posiciones
        if(vessel.startAtAnchorage == "False"):
            problem.set_initial_value(vessel_on(aux, pos0), True)
        elif(vessel.startAtAnchorage == "True"):
            problem.set_initial_value(vessel_on(aux, pos2), True)
            #Condiciones de los vessels
        problem.set_initial_value(isFueled(aux), False)
        
            #Tiempos
        problem.set_initial_value(arrTime_init(aux), vessel.timeToAnchorage) #Revisar tiempos
        # problem.set_initial_value(waitTime(vessel1), 100)
        problem.set_initial_value(arrTime_delta(aux), 15)
        problem.set_initial_value(bunkTime(aux), vessel.bunkeringTime)
        problem.set_initial_value(arrTime_exit(aux), 15)   
        problem.set_initial_value(fuelRequiredVessel(aux), vessel.fuelRequested)    

        
            # Add Goal
        problem.add_goal(isFueled(aux))
        problem.add_goal(vessel_on(aux, pos3))
        problem.add_goal(showedVessel(aux))
    
    
    
for barge in listBarges:
    if (barge.available == "True"):
        aux = Object(barge.name, Barge)
        problem.add_object(aux)

        #Posiciones    
        problem.set_initial_value(barge_on(aux, pos3), True)
        
        problem.set_initial_value(actualFuelBarge(aux), barge.fuelAvailable)
        
        problem.set_initial_value(totalFuelBarge(aux), barge.fuelCapacity)
    
        #Goal
        problem.add_goal(used(aux))


#Add Objects


problem.add_object(pos0)
problem.add_object(pos1)
problem.add_object(pos2)
problem.add_object(pos3)

problem.add_object(pos4)

    # Define Initial state

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

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

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

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

#Zona Refueling Barge
problem.set_initial_value(next(pos2, pos4), True)
problem.set_initial_value(next(pos4, pos2), True)



problem.set_initial_value(isDelta(pos2), True)


problem.set_initial_value(isRefuelZone(pos4), True)


    #Capacidades
problem.set_initial_value(capacity(pos0), 100)
problem.set_initial_value(capacity(pos1), 100)
problem.set_initial_value(capacity(pos3), 100)
aux =len(tuple(problem.objects(Vessel)))-numVesselp0
problem.set_initial_value(capacity(pos2), int(listData[0].deltaAnch_Capacity) - aux)
problem.set_initial_value(capacity(pos4), 100)

    # Add Goal    
#problem.add_goal(LE(accumulator, len(tuple(problem.objects(Vessel)))+len(tuple(problem.objects(Barge))))) # +2 Numero de gabarras
problem.add_goal(LE(accumulator, numVesselp0+len(tuple(problem.objects(Barge)))))
problem.add_fluent(accumulator, default_initial_value=0) 
# assumes all the vessels start in pos0
problem.add_fluent(vessels_in_p0, default_initial_value=numVesselp0)


#print(problem)


for vessel in listVessels:
    print(f"{vessel.name} {vessel.fuelRequested}")


for barge in listBarges:
    print(f"{barge.name} {barge.fuelCapacity} {barge.fuelAvailable}")


problem.add_quality_metric(up.model.metrics.MinimizeSequentialPlanLength())

# 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)
        print("")
        print("")
        
    else:
        print("No plan found.")
        


        

listTimes = []
listObjs = []
with SequentialSimulator(problem=problem) as simulator:
    
    current_state = simulator.get_initial_state()
    states = [current_state]
    for action_instance in result.plan.actions:
        current_state = simulator.apply(current_state, action_instance)
        if current_state is None:
            print(f'Error in applying: {action_instance}')
            break
        states.append(current_state)
        if action_instance.action == showTime:
            current_time_value = list(current_state._values.values())[1]            
            current_time_value = list(current_state._values.values())[1]
            listTimes.append(current_time_value)
            listObjs.append(action_instance._params[0])
            print(f"Tiempo total estimado {action_instance._params[0]}: {current_time_value}")
          #  print(f"Fuel Gabarra {action_instance._params[0]}: {current_time_value}")
        
    
    
    
    
stringTime = ""
for time, obj in zip(listTimes, listObjs):
    stringTime =stringTime + f"Tiempo total estimado {obj}: {time}\n"
    
    
    


label = ttk.Label(root, text=result.plan)
label.pack()


label = ttk.Label(root, text=stringTime)
label.pack()

    
root.mainloop()