def __init__(self, name):
self.element_name = name
self.truck_list = []
self.door_empty = True
self.good_store = GoodStore()
self.good_transfer_time = 0
self.transfer_finished = False
self.station = 0
def load_goods(self, current_time):
self.current_time = current_time
self.loading_truck.going_goods = deepcopy(self.reserved_goods)
self.reserved_goods = GoodStore()
self.next_state()
self.finish_time = current_time + self.loading_truck.changeover_time
if self.sequence:
self.sequence.pop(0)
def __init__(self, transfer_time):
"""
Initialize the station by creating doors and types
:return:
"""
self.receiving_doors = {}
self.shipping_doors = {}
self.not_ready_goods = {}
self.station_goods = GoodStore()
self.good_transfer_time = transfer_time
def __init__(self, station, name):
self.station = station
self.door_name = name
self.trpe = 'Shipping'
self.truck = None
self.status = ['empty', 'loading', 'waiting']
self.status_number = 0
self.good_list = GoodStore()
self.sequence = []
self.station = station
self.waiting_trucks = 0
self.loading_truck = None
self.reserved_goods = GoodStore()
self.finish_time = 0
self.current_time = 0
def __init__(self, truck_data, inbound_data):
Truck.__init__(self, truck_data)
self.truck_type = 0
self.state_list = ('coming', 'waiting', 'start_deploy', 'deploying', 'done')
self.arrival_time = inbound_data['arrival_time']
self.mu = inbound_data['mu']
self.product_per_truck = inbound_data['product_per_truck']
self.inbound_gdj = 0
self.door_number = 0
self.receive_door = 0
self.coming_good_amounts = {}
self.bounds = 0
self.coming_goods = GoodStore()
class ReceivingDoor():
def __init__(self, name):
self.element_name = name
self.truck_list = []
self.door_empty = True
self.good_store = GoodStore()
self.good_transfer_time = 0
self.transfer_finished = False
self.station = 0
def check_door(self, truck_name):
"""
check if its time for the truck
"""
if self.door_empty:
if self.truck_list:
if truck_name == self.truck_list[0]:
self.truck_list.pop(0)
self.door_empty = False
return True
else:
return False
else:
return False
def transfer_goods_to_station(self, current_time):
if current_time == self.good_transfer_time:
self.station.good_store.add_good_dict(self.good_store.good_dictionary)
self.good_store.reset_goods()
if self.transfer_finished:
self.transfer_finished = False
return self.good_transfer_time
else:
return -1
def show_sequence(self):
"""shows goods of the truck in a dialog"""
print("show goods: ", self.element_name)
good_dialog = QMessageBox()
good_dialog.setWindowTitle("Sequence of " + self.element_name)
message = str(self.truck_list)
good_dialog.setText(message)
good_dialog.exec_()
def load_goods(self, current_time):
self.current_time = current_time
self.loading_truck.going_goods = deepcopy(self.reserved_goods)
self.reserved_goods = GoodStore()
self.next_state()
self.finish_time = current_time + self.loading_truck.changeover_time
if self.sequence:
self.sequence.pop(0)
def __init__(self):
Truck.__init__(self)
self.behaviour_list = ['coming', 'waiting_to_load', 'changeover', 'not_ready_to_load', 'ready_to_load', 'must_load', 'loading', 'changeover2', 'done']
self.current_state = 0
self.function_list = [self.coming, self.waiting_to_load, self.changeover, self.not_ready_to_load, self.ready_to_load, self.must_load, self.loading, self.changeover2, self.done]
self.current_time = 0
self.good = GoodStore()
self.needed_goods = {}
self.lower_bound = 0
self.upper_bound = 0
self.good_amount = 0
def __init__(self, transfer_time):
"""
Initialize the station by creating doors and types
:return:
"""
self.receiving_doors = {}
self.shipping_doors = {}
self.not_ready_goods = {}
self.station_goods = GoodStore()
self.good_transfer_time = transfer_time
def __init__(self):
self.element_name = ""
self.truck_type = ""
self.truck_times = OrderedDict()
self.state_functions = OrderedDict()
self.truck_states = []
self.state_change = False
self.coming_time = 0
self.changeover_time = 0
self.good_loading_time = 0
self.good_unloading_time = 0
self.good_transfer_time = 0
self.station = 0
self.lower_boundary = 0
self.upper_boundary = 0
self.coming_good_store = GoodStore()
self.going_good_store = GoodStore()
self.coming_good_dict = dict()
self.going_good_dict = dict()
self.state = 0
self.current_time = 0
self.truck_results = TruckResults()
self.first_door = ""
self.second_door = ""
self.current_door = ""
self.next_state_time = 0
self.simulation_state = 0
self.truck_transfer_time = 0
# define state functions
self.state_functions["coming"] = self.coming
self.state_functions["waiting_to_deploy"] = self.waiting_to_deploy
self.state_functions["waiting_to_load"] = self.waiting_to_load
self.state_functions["changeover_load"] = self.changeover_load
self.state_functions["changeover_deploy"] = self.changeover_deploy
self.state_functions["deploying"] = self.deploying
self.state_functions["changeover_fin"] = self.changeover_fin
self.state_functions["changeover_mid"] = self.changeover_mid
self.state_functions["not_enough_goods"] = self.not_enough_goods
self.state_functions["loading"] = self.loading
self.state_functions["done"] = self.done
def __init__(self, name, station, door_list):
Door.__init__(self, name, station)
self.truck_list = []
self.behaviour_list = ['empty', 'waiting_to_load', 'start_loading', 'must_load', 'loading', "waiting"]
self.function_list = [self.empty, self.waiting_to_load, self.start_loading, self.must_load, self.loading, self.waiting]
self.next_truck_number = 0
self.waiting_name = 'waiting_to_load'
self.good_ready = False
self.current_goods = []
self.goods = GoodStore()
self.transfer_amounts = {}
self.door_list = door_list
self.critic = False
def __init__(self, truck_data, outbound_data):
Truck.__init__(self, truck_data)
self.truck_type = 1
self.state_list = ('coming', 'waiting_to_load', 'not_ready_to_load', 'ready_to_load', 'must_load', 'loading', 'done')
self.going_goods = GoodStore()
self.going_good_amounts = {}
self.finish_time = 0
self.outbound_gdj = 0
self.shipping_door = 0
self.shipping_door_name = None
self.arrival_time = outbound_data['arrival_time']
self.mu = outbound_data['mu']
self.product_per_truck = outbound_data['product_per_truck']
def __init__(self, truck_data, compound_data):
Truck.__init__(self, truck_data)
self.truck_type = 2
self.state_list = ('coming', 'waiting', 'start_deploy', 'deploying', 'transfering', 'waiting_to_load', 'not_needed_to_load', 'ready_to_load', 'must_load', 'loading', 'done')
self.coming_goods = GoodStore()
self.going_goods = GoodStore()
self.coming_good_amounts = {}
self.going_good_amounts = {}
self.inbound_gdj = 0
self.outbound_gdj = 0
self.finish_time = 0
self.receiving_door = 0
self.shipping_door = 0
self.receiving_door_name = None
self.shipping_door_name = None
# compound truck data
self.arrival_time = compound_data['arrival_time']
self.mu = compound_data['mu']
self.transfer_time = compound_data['transfer_time']
self.inbound_product_per_truck = compound_data['inbound_product_per_truck']
self.outbound_product_per_truck = compound_data['outbound_product_per_truck']
class InboundTruck(Truck):
"""
Inbound truck object
"""
def __init__(self):
Truck.__init__(self)
self.behaviour_list = ['coming', 'waiting_to_deploy', 'changeover', 'deploying', 'changeover2', 'done']
self.function_list = [self.coming, self.waiting, self.changeover, self.deploying, self.changeover2, self.done]
self.good = GoodStore()
def waiting(self):
pass
def changeover(self):
if self.current_time == self.next_state_time:
self.next_state()
self.current_door.next_state()
self.next_state_time = self.good.calculate_load_time() + self.current_time
def deploying(self):
if self.current_time == self.next_state_time:
self.next_state_time = self.changeover_time + self.current_time
self.current_door.goods_list.append(copy.deepcopy(self.good))
self.current_door.good_times.append(self.current_time + self.current_door.good_transfer_time - 1)
self.good.clear_goods()
self.current_door.next_state()
self.next_state()
def changeover2(self):
if self.current_time == self.next_state_time:
self.next_state()
self.current_door.next_state()
self.finish_time = self.current_time
def done(self):
pass
def __init__(self, station, name):
self.station = station
self.door_name = name
self.trpe = 'Shipping'
self.truck = None
self.status = ['empty', 'loading', 'waiting']
self.status_number = 0
self.good_list = GoodStore()
self.sequence = []
self.station = station
self.waiting_trucks = 0
self.loading_truck = None
self.reserved_goods = GoodStore()
self.finish_time = 0
self.current_time = 0
class Station(object):
"""
Station for the goods to come in and go out.
"""
def __init__(self, transfer_time):
"""
Initialize the station by creating doors and types
:return:
"""
self.receiving_doors = {}
self.shipping_doors = {}
self.not_ready_goods = {}
self.station_goods = GoodStore()
self.good_transfer_time = transfer_time
def add_receiving_door(self):
"""
creates a receiving door
:return:
"""
name = "recv" + str(len(self.receiving_doors))
door = ReceivingDoor(self, name)
self.receiving_doors[name] = door
def clear_door_sequences(self):
for doors in itertools.chain(self.receiving_doors.values(), self.shipping_doors.values()):
doors.sequence = []
def remove_receiving_door(self):
"""
removes a receiving door from the station
:return:
"""
name = "recv" + str(len(self.receiving_doors) - 1)
del self.receiving_doors[name]
def add_shipping_door(self):
"""
creates a shipping door
:return:
"""
name = "ship" + str(len(self.shipping_doors))
door = ShippingDoor(self, name)
self.shipping_doors[name] = door
def remove_shipping_door(self):
"""
removes a receiving door from the station
:return:
"""
name = "ship" + str(len(self.shipping_doors) - 1)
del self.shipping_doors[name]
def check_states(self):
logging.debug("station goods")
self.station_goods.log_goods()
for doors in itertools.chain(self.receiving_doors.values()):
if doors.good_list:
self.add_goods(doors.good_list)
def add_goods(self, good_store, current_time):
for goods in good_store.good_list.values():
for good in goods:
good.transfer_time = current_time + self.good_transfer_time
if good.type in self.not_ready_goods.keys():
self.not_ready_goods[good.type].append(good)
else:
self.not_ready_goods[good.type] = []
self.not_ready_goods[good.type].append(good)
def check_good_transfer(self, current_time):
"""
check if goods are ready to transfer
:return:
"""
for goods in self.not_ready_goods.values():
for good in goods:
if good.transfer_time == current_time:
self.station_goods.add_good(good.type, good.amount)
logging.debug("Station: Unloading goods from truck")
self.check_states()
def log_goods(self):
total_good = 0
for good_type in self.station_goods.values():
for good_amounts in good_type:
total_good += good_amounts.amount
# logging.debug("--Station: good type:{0}, amount:{1}".format(good_type[0].type, total_good))
def remove_goods(self, goods):
for good in goods:
max_item = None
moved_good = 0
error = good.amount - moved_good
while error > 0:
for items in self.station_goods[good.type]:
next_item = items
if max_item is None or max_item.amount < next_item.amount:
max_item = next_item
if max_item.amount < error:
moved_good += max_item.amount
max_item.amount = 0
elif max_item.amount >= error:
moved_good += error
max_item.amount -= error
error = good.amount - moved_good
logging.debug("Station: Loading goods to truck")
self.log_goods()
class CompoundTruck(Truck):
"""
compound truck class
"""
def __init__(self, truck_data, compound_data):
Truck.__init__(self, truck_data)
self.truck_type = 2
self.state_list = ('coming', 'waiting', 'start_deploy', 'deploying', 'transfering', 'waiting_to_load', 'not_needed_to_load', 'ready_to_load', 'must_load', 'loading', 'done')
self.coming_goods = GoodStore()
self.going_goods = GoodStore()
self.coming_good_amounts = {}
self.going_good_amounts = {}
self.inbound_gdj = 0
self.outbound_gdj = 0
self.finish_time = 0
self.receiving_door = 0
self.shipping_door = 0
self.receiving_door_name = None
self.shipping_door_name = None
# compound truck data
self.arrival_time = compound_data['arrival_time']
self.mu = compound_data['mu']
self.transfer_time = compound_data['transfer_time']
self.inbound_product_per_truck = compound_data['inbound_product_per_truck']
self.outbound_product_per_truck = compound_data['outbound_product_per_truck']
def calculate_twogd(self):
"""
calculates upper limit for coming times
:return:
"""
self.two_gdj = (2 * self.mu * self.tightness_factor * self.inbound_product_per_truck) / (2 - self.tightness_factor * self.mu * self.makespan_factor)
def calculate_gdj(self):
"""
calculate gdj
:return:
"""
self.calculate_twogd()
self.inbound_gdj = int(uniform(self.arrival_time, self.two_gdj))
self.outbound_gdj = self.inbound_gdj + (self.mu - 1) * self.changeover_time + self.mu * self.inbound_product_per_truck * self.loading_time + self.transfer_time
A = self.inbound_gdj + (self.mu - 1) * self.changeover_time + self.mu * self.inbound_product_per_truck * self.loading_time + self.transfer_time +(self.mu - 1) * self.changeover_time + self.mu * self.outbound_product_per_truck * self.loading_time
self.bounds = [A * self.alpha, A*(self.gamma)]
self.finish_time = self.inbound_gdj
def load_gdj(self):
pass
def current_action(self, current_time):
self.log_truck()
self.current_time = current_time
if self.current_state == 0:
self.coming()
if self.current_state == 1:
self.waiting_deploying()
if self.current_state == 2:
self.start_deploy()
if self.current_state == 3:
self.deploy_goods()
if self.current_state == 4:
self.transfering()
if self.current_state == 5:
self.waiting_loading()
if self.current_state == 6:
self.not_ready_to_load()
if self.current_state == 7:
self.ready_to_load()
if self.current_state == 8:
self.must_load()
if self.current_state == 9:
self.loading_goods()
if self.current_state == 10:
self.leaving()
def not_ready_to_load(self):
"""
check if loading time is later than lower bound
"""
self.good_amounts = 0
for good_amount in self.going_good_amounts.values():
self.good_amounts += good_amount
self.time_to_load = self.good_amounts * self.loading_time
load_finish = self.current_time + self.time_to_load
if load_finish < self.bounds[0]:
logging.debug("Not ready to load: {0}".format(self.truck_name))
elif load_finish < self.bounds[1]:
logging.debug("Ready to load: {0}".format(self.truck_name))
self.next_state()
elif load_finish >= self.bounds[1]:
self.current_state = 8
def ready_to_load(self):
"""
rezerve goods needed, check if must load
"""
logging.debug("Ready to load: {0}".format(self.truck_name))
logging.debug("Going good amounts {0}: {1}".format(self.truck_name, self.going_good_amounts))
self.shipping_door.reserve_goods(self.going_good_amounts)
self.finish_time = self.current_time + self.time_to_load
logging.debug("Loading finish {0}: {1}".format(self.truck_name, self.finish_time))
if self.shipping_door.check_goods():
self.current_state = 9
logging.info('Truck {0} started loading at {1}'.format(self.truck_name, self.current_time))
elif self.finish_time >= self.bounds[1]:
self.next_state()
#
# if self.shipping_door.check_goods():
# self.current_state = 9
# self.finish_time = self.current_time + self.time_to_load
# elif load_finish >= self.bounds[1]:
# self.finish_time = self.current_time + self.time_to_load
# self.next_state()
def must_load(self):
"""
must load goods, move goods, wait for finish time
"""
logging.debug("Must to load: {0}".format(self.truck_name))
load_finish = self.current_time + self.time_to_load
self.shipping_door.reserve_critical_goods(self.going_good_amounts)
self.finish_time = self.current_time + self.time_to_load
if self.shipping_door.check_goods():
self.next_state()
def loading_goods(self):
if self.current_time == self.finish_time:
logging.info('Truck {0} finished loading at {1}'.format(self.truck_name, self.current_time))
self.shipping_door.load_goods(self.current_time)
self.next_state()
def start_deploy(self):
logging.info('Truck {0} started unloading goods at {1}'.format(self.truck_name, self.current_time))
total = 0
logging.debug("----Deploy goods:")
total += self.coming_goods.total()
self.finish_time = int(self.current_time + total * self.loading_time)
logging.debug("----Finish time: {0}".format(self.finish_time))
self.next_state()
def deploy_goods(self):
if self.current_time == self.finish_time:
logging.info('Truck {0} finished unloading goods at {1}'.format(self.truck_name, self.current_time))
self.receiving_door.deploy_goods(self.coming_goods, self.current_time)
self.next_state()
self.finish_time = self.current_time + self.transfer_time + self.changeover_time
def waiting_deploying(self):
pass
def coming(self):
if self.current_time == self.inbound_gdj:
self.next_state()
def waiting_loading(self):
pass
def transfering(self):
if self.current_time == self.finish_time:
self.next_state()
def leaving(self):
pass
def calculate_error(self):
"""
calculate error values
"""
logging.info("truck {0}, finish time {1}, bounds {2}".format(self.truck_name, self.finish_time, self.bounds))
if self.bounds[0] <= self.finish_time <= self.bounds[1]:
self.error = 0
elif self.finish_time < self.bounds[0]:
self.error = self.finish_time - self.bounds[0]
else:
self.error = self.finish_time - self.bounds[1]
class ShippingDoor(object):
"""
Shipping doors of the station
"""
def __init__(self, station, name):
self.station = station
self.door_name = name
self.trpe = 'Shipping'
self.truck = None
self.status = ['empty', 'loading', 'waiting']
self.status_number = 0
self.good_list = GoodStore()
self.sequence = []
self.station = station
self.waiting_trucks = 0
self.loading_truck = None
self.reserved_goods = GoodStore()
self.finish_time = 0
self.current_time = 0
def set_truck_doors(self):
for truck in self.sequence:
truck.shipping_door = self
truck.shipping_door_name = self.door_name
def current_action(self, current_time):
self.current_time = current_time
logging.debug("Reserved goods: {0}".format(self.reserved_goods))
if self.status_number == 0:
self.no_truck()
if self.status_number == 1:
self.load()
if self.status_number == 2:
self.wait_truck_change()
def next_state(self):
self.status_number += 1
def no_truck(self):
if len(self.sequence) != 0:
self.loading_truck = self.sequence[0]
if self.loading_truck.state_list[
self.loading_truck.current_state] == 'waiting_to_load':
self.loading_truck.next_state()
self.next_state()
def check_goods(self):
"""
check if enough in reserved goods
:return:
"""
logging.debug("---Check Goods")
logging.debug("---Reserved goods:")
for reserved_good in self.reserved_goods.good_list:
logging.debug("Amount of reserved {0} : {1}".format(
reserved_good, self.reserved_goods.total_good(reserved_good)))
logging.debug("---Station goods:")
for station_good in self.station.station_goods.good_list:
logging.debug("Amount in station{0} : {1}".format(
station_good,
self.station.station_goods.total_good(station_good)))
enough_goods = True
for good_name, good_amount in self.loading_truck.going_good_amounts.items(
):
good_name = str(good_name)
if good_amount == self.reserved_goods.total_good(good_name):
logging.debug('Good {0} ready'.format(good_name))
else:
enough_goods = enough_goods and False
if enough_goods:
logging.debug('Enough goods')
logging.info('Truck {0} started loading at {1}'.format(
self.loading_truck.truck_name, self.current_time))
return enough_goods
def reserve_goods(self, good_amounts):
"""
reserve goods
:param good_amounts:
:return:
"""
logging.debug("---Reserve Goods")
for good_name, needed_good_amount in good_amounts.items():
good_name = str(good_name)
logging.debug("Good name: {0}".format(good_name))
logging.debug("Needed amount: {0}".format(needed_good_amount))
if good_name in self.station.station_goods.good_list:
logging.debug("Good in station: {0}".format(good_name))
if good_name in self.reserved_goods.good_list.keys():
logging.debug(
"Good reserved before: {0}".format(good_name))
needed_good_amount = needed_good_amount - self.reserved_goods.total_good(
good_name)
logging.debug("needed amount {0}: {1}".format(
good_name, needed_good_amount))
if needed_good_amount == 0:
continue
moved_amount = self.station.station_goods.move_good(
good_name, needed_good_amount)
needed_good_amount -= moved_amount
self.reserved_goods.add_good(good_name, moved_amount)
def reserve_critical_goods(self, good_amounts):
self.reserve_goods(good_amounts)
if self.check_goods():
return
else:
for good_name, needed_good_amount in good_amounts.items():
good_name = str(good_name)
if good_name in self.reserved_goods.good_list:
needed_good_amount -= self.reserved_goods.total_good(
good_name)
if needed_good_amount == 0:
continue
moved_amount = 0
for shipping_door in self.station.shipping_doors.values():
if shipping_door == self:
break
if needed_good_amount == 0:
break
if good_name in shipping_door.reserved_goods.good_list:
moved_amount += shipping_door.reserved_goods.move_good(
good_name, needed_good_amount)
if moved_amount == 0:
return
self.reserved_goods.add_good(good_name, moved_amount)
def wait_truck_change(self):
if self.current_time == self.finish_time:
self.status_number = 0
def load_goods(self, current_time):
self.current_time = current_time
self.loading_truck.going_goods = deepcopy(self.reserved_goods)
self.reserved_goods = GoodStore()
self.next_state()
self.finish_time = current_time + self.loading_truck.changeover_time
if self.sequence:
self.sequence.pop(0)
def load(self):
pass # wait for truck
def changeover2(self):
if self.current_time == self.next_state_time:
self.current_door.next_state()
self.next_state()
self.next_state_time = self.transfer_time + self.current_time
self.good = GoodStore()
class Station(object):
"""
Station for the goods to come in and go out.
"""
def __init__(self, transfer_time):
"""
Initialize the station by creating doors and types
:return:
"""
self.receiving_doors = {}
self.shipping_doors = {}
self.not_ready_goods = {}
self.station_goods = GoodStore()
self.good_transfer_time = transfer_time
def add_receiving_door(self):
"""
creates a receiving door
:return:
"""
name = 'recv' + str(len(self.receiving_doors))
door = ReceivingDoor(self, name)
self.receiving_doors[name] = door
def clear_door_sequences(self):
for doors in itertools.chain(self.receiving_doors.values(),
self.shipping_doors.values()):
doors.sequence = []
def remove_receiving_door(self):
"""
removes a receiving door from the station
:return:
"""
name = 'recv' + str(len(self.receiving_doors) - 1)
del self.receiving_doors[name]
def add_shipping_door(self):
"""
creates a shipping door
:return:
"""
name = 'ship' + str(len(self.shipping_doors))
door = ShippingDoor(self, name)
self.shipping_doors[name] = door
def remove_shipping_door(self):
"""
removes a receiving door from the station
:return:
"""
name = 'ship' + str(len(self.shipping_doors) - 1)
del self.shipping_doors[name]
def check_states(self):
logging.debug("station goods")
self.station_goods.log_goods()
for doors in itertools.chain(self.receiving_doors.values()):
if doors.good_list:
self.add_goods(doors.good_list)
def add_goods(self, good_store, current_time):
for goods in good_store.good_list.values():
for good in goods:
good.transfer_time = current_time + self.good_transfer_time
if good.type in self.not_ready_goods.keys():
self.not_ready_goods[good.type].append(good)
else:
self.not_ready_goods[good.type] = []
self.not_ready_goods[good.type].append(good)
def check_good_transfer(self, current_time):
"""
check if goods are ready to transfer
:return:
"""
for goods in self.not_ready_goods.values():
for good in goods:
if good.transfer_time == current_time:
self.station_goods.add_good(good.type, good.amount)
logging.debug("Station: Unloading goods from truck")
self.check_states()
def log_goods(self):
total_good = 0
for good_type in self.station_goods.values():
for good_amounts in good_type:
total_good += good_amounts.amount
# logging.debug("--Station: good type:{0}, amount:{1}".format(good_type[0].type, total_good))
def remove_goods(self, goods):
for good in goods:
max_item = None
moved_good = 0
error = good.amount - moved_good
while error > 0:
for items in self.station_goods[good.type]:
next_item = items
if max_item is None or max_item.amount < next_item.amount:
max_item = next_item
if max_item.amount < error:
moved_good += max_item.amount
max_item.amount = 0
elif max_item.amount >= error:
moved_good += error
max_item.amount -= error
error = good.amount - moved_good
logging.debug("Station: Loading goods to truck")
self.log_goods()
class ShippingDoor(Door):
def __init__(self, name, station, door_list):
Door.__init__(self, name, station)
self.truck_list = []
self.behaviour_list = ['empty', 'waiting_to_load', 'start_loading', 'must_load', 'loading', "waiting"]
self.function_list = [self.empty, self.waiting_to_load, self.start_loading, self.must_load, self.loading, self.waiting]
self.next_truck_number = 0
self.waiting_name = 'waiting_to_load'
self.good_ready = False
self.current_goods = []
self.goods = GoodStore()
self.transfer_amounts = {}
self.door_list = door_list
self.critic = False
def run(self, current_time):
self.current_time = current_time
self.function_list[self.current_state]()
def empty(self):
try:
self.truck = self.truck_list[self.next_truck_number]
if self.truck.behaviour_list[self.truck.current_state] == self.waiting_name:
self.good_ready = False
self.current_goods = []
self.transfer_amounts = {}
self.needed_goods = []
self.next_state()
self.truck.next_state()
self.truck.times['waiting_finish'] = self.current_time
self.truck.relevant_data = self.door_name
self.truck.next_state_time = self.current_time + self.truck.changeover_time
self.truck.current_door = self
self.next_truck_number += 1
self.needed_goods = self.truck.needed_goods
except:
pass
def waiting_to_load(self):
pass
#print('waiting_to_load')
def start_loading(self):
self.check_self()
self.transfer_goods(self.station)
self.check_ready()
if self.check_other_trucks():
self.next_state()
self.truck.next_state()
def check_other_trucks(self):
for i, truck in enumerate(self.truck_list):
if i >= self.next_truck_number:
if truck.upper_bound < self.current_time:
return True
return False
def must_load(self):
self.critic = True
self.check_self()
self.transfer_goods(self.station)
#self.critic_transfer_goods()
self.check_ready()
def loading(self):
pass
def check_self(self):
self.current_goods = self.goods.good_amounts()
for good_name, good_amount in self.needed_goods.items():
if good_name in self.current_goods:
if self.current_goods[good_name] >= self.needed_goods[good_name]:
self.transfer_amounts[good_name] = 0
continue
elif self.current_goods[good_name] < self.needed_goods[good_name]:
self.transfer_amounts[good_name] = self.needed_goods[good_name] - self.current_goods[good_name]
else:
self.transfer_amounts[good_name] = copy.deepcopy(self.needed_goods[good_name])
def transfer_goods(self, transfor_from=None):
try:
if not self.good_ready:
for good_name, good_amount in self.transfer_amounts.items():
remove_goods = transfor_from.goods_list.remove_good(good_name, good_amount)
for remove_good in remove_goods:
self.goods.add_good(good_name, remove_good[0], remove_good[1])
except:
pass
def critic_transfer_goods(self):
for transfer_from in self.door_list.values():
if not transfer_from == self:
if type(transfer_from) is ShippingDoor:
if transfer_from.critic == False:
self.check_ready()
self.check_self()
if self.good_ready:
break
self.transfer_goods(transfer_from)
def check_ready(self):
if sum(self.transfer_amounts.values()) == 0:
self.good_ready = True
def waiting(self):
self.critic = False
def __init__(self):
self.good_store = GoodStore()
def __init__(self):
self.truck_type = ""
self.truck_name = ""
self.times = dict()
self.coming_goods = GoodStore()
self.going_goods = GoodStore()
class ShippingDoor(object):
"""
Shipping doors of the station
"""
def __init__(self, station, name):
self.station = station
self.door_name = name
self.trpe = 'Shipping'
self.truck = None
self.status = ['empty', 'loading', 'waiting']
self.status_number = 0
self.good_list = GoodStore()
self.sequence = []
self.station = station
self.waiting_trucks = 0
self.loading_truck = None
self.reserved_goods = GoodStore()
self.finish_time = 0
self.current_time = 0
def set_truck_doors(self):
for truck in self.sequence:
truck.shipping_door = self
truck.shipping_door_name = self.door_name
def current_action(self, current_time):
self.current_time = current_time
logging.debug("Reserved goods: {0}".format(self.reserved_goods))
if self.status_number == 0:
self.no_truck()
if self.status_number == 1:
self.load()
if self.status_number == 2:
self.wait_truck_change()
def next_state(self):
self.status_number += 1
def no_truck(self):
if len(self.sequence) != 0:
self.loading_truck = self.sequence[0]
if self.loading_truck.state_list[self.loading_truck.current_state] == 'waiting_to_load':
self.loading_truck.next_state()
self.next_state()
def check_goods(self):
"""
check if enough in reserved goods
:return:
"""
logging.debug("---Check Goods")
logging.debug("---Reserved goods:")
for reserved_good in self.reserved_goods.good_list:
logging.debug("Amount of reserved {0} : {1}".format(reserved_good, self.reserved_goods.total_good(reserved_good)))
logging.debug("---Station goods:")
for station_good in self.station.station_goods.good_list:
logging.debug("Amount in station{0} : {1}".format(station_good, self.station.station_goods.total_good(station_good)))
enough_goods = True
for good_name, good_amount in self.loading_truck.going_good_amounts.items():
good_name = str(good_name)
if good_amount == self.reserved_goods.total_good(good_name):
logging.debug('Good {0} ready'.format(good_name))
else:
enough_goods = enough_goods and False
if enough_goods:
logging.debug('Enough goods')
logging.info('Truck {0} started loading at {1}'.format(self.loading_truck.truck_name, self.current_time))
return enough_goods
def reserve_goods(self, good_amounts):
"""
reserve goods
:param good_amounts:
:return:
"""
logging.debug("---Reserve Goods")
for good_name, needed_good_amount in good_amounts.items():
good_name = str(good_name)
logging.debug("Good name: {0}".format(good_name))
logging.debug("Needed amount: {0}".format(needed_good_amount))
if good_name in self.station.station_goods.good_list:
logging.debug("Good in station: {0}".format(good_name))
if good_name in self.reserved_goods.good_list.keys():
logging.debug("Good reserved before: {0}".format(good_name))
needed_good_amount = needed_good_amount - self.reserved_goods.total_good(good_name)
logging.debug("needed amount {0}: {1}".format(good_name, needed_good_amount))
if needed_good_amount == 0:
continue
moved_amount = self.station.station_goods.move_good(good_name, needed_good_amount)
needed_good_amount -= moved_amount
self.reserved_goods.add_good(good_name, moved_amount)
def reserve_critical_goods(self, good_amounts):
self.reserve_goods(good_amounts)
if self.check_goods():
return
else:
for good_name, needed_good_amount in good_amounts.items():
good_name = str(good_name)
if good_name in self.reserved_goods.good_list:
needed_good_amount -= self.reserved_goods.total_good(good_name)
if needed_good_amount == 0:
continue
moved_amount = 0
for shipping_door in self.station.shipping_doors.values():
if shipping_door == self:
break
if needed_good_amount == 0:
break
if good_name in shipping_door.reserved_goods.good_list:
moved_amount += shipping_door.reserved_goods.move_good(good_name, needed_good_amount)
if moved_amount == 0:
return
self.reserved_goods.add_good(good_name, moved_amount)
def wait_truck_change(self):
if self.current_time == self.finish_time:
self.status_number = 0
def load_goods(self, current_time):
self.current_time = current_time
self.loading_truck.going_goods = deepcopy(self.reserved_goods)
self.reserved_goods = GoodStore()
self.next_state()
self.finish_time = current_time + self.loading_truck.changeover_time
if self.sequence:
self.sequence.pop(0)
def load(self):
pass # wait for truck
class Truck():
def __init__(self):
self.element_name = ""
self.truck_type = ""
self.truck_times = OrderedDict()
self.state_functions = OrderedDict()
self.truck_states = []
self.state_change = False
self.coming_time = 0
self.changeover_time = 0
self.good_loading_time = 0
self.good_unloading_time = 0
self.good_transfer_time = 0
self.station = 0
self.lower_boundary = 0
self.upper_boundary = 0
self.coming_good_store = GoodStore()
self.going_good_store = GoodStore()
self.coming_good_dict = dict()
self.going_good_dict = dict()
self.state = 0
self.current_time = 0
self.truck_results = TruckResults()
self.first_door = ""
self.second_door = ""
self.current_door = ""
self.next_state_time = 0
self.simulation_state = 0
self.truck_transfer_time = 0
# define state functions
self.state_functions["coming"] = self.coming
self.state_functions["waiting_to_deploy"] = self.waiting_to_deploy
self.state_functions["waiting_to_load"] = self.waiting_to_load
self.state_functions["changeover_load"] = self.changeover_load
self.state_functions["changeover_deploy"] = self.changeover_deploy
self.state_functions["deploying"] = self.deploying
self.state_functions["changeover_fin"] = self.changeover_fin
self.state_functions["changeover_mid"] = self.changeover_mid
self.state_functions["not_enough_goods"] = self.not_enough_goods
self.state_functions["loading"] = self.loading
self.state_functions["done"] = self.done
def add_good_types(self, number_of_goods):
for i in range(number_of_goods):
self.coming_good_store.add_good_type(i)
def add_start_goods(self, start_goods):
for i in range(len(start_goods)):
self.coming_good_dict[str(i)] = start_goods[i]
self.coming_good_store.add_good(start_goods[i], str(i), self.element_name)
def add_last_goods(self, last_goods):
for i in range(len(last_goods)):
self.going_good_dict[str(i)] = last_goods[i]
self.going_good_store.add_good_type(str(i))
def show_goods(self):
"""shows goods of the truck in a dialog"""
print("show goods: ", self.element_name)
good_dialog = QMessageBox()
good_dialog.setWindowTitle("Goods of " + self.element_name)
message = "Current Coming Goods:\n"
message += self.coming_good_store.print_goods()
message += "\nCurrent Going Goods:\n"
message += self.going_good_store.print_goods()
message += "\nPlanned Going Goods:\n"
message += str(self.going_good_dict)
good_dialog.setText(message)
good_dialog.exec_()
def show_times (self):
"""shows the times of the truck"""
good_dialog = QMessageBox()
good_dialog.setWindowTitle("Times of " + self.element_name)
message = ""
for state_name, state_time in self.truck_times.items():
message += state_name
message += ": "
message += str(state_time)
message += "\n"
message += "\n"
message += "Current State: "
message += self.state_list[self.state]
message += "\n"
message += "Next State: "
if self.state < len(self.state_list) - 1:
message += self.state_list[self.state + 1]
message += "\n"
message += "Next state Time: "
message += str(self.next_state_time)
message += "\n"
good_dialog.setText(message)
good_dialog.exec_()
def return_truck_results(self):
self.truck_results.truck_name = self.element_name
self.truck_results.truck_type = self.truck_type
self.truck_results.times = self.truck_times
self.truck_results.coming_goods = self.coming_good_store
self.truck_results.going_goods = self.going_good_store
return self.truck_results
def step(self):
"""
one tep forward
"""
state_name = self.state_list[self.state]
self.state_change = False
self.state_functions[state_name]()
if self.state_change:
return self.next_state_time
else:
return 0
def check_next_state_time (self):
"""check next if time for next state has come"""
if self.current_time == self.next_state_time:
return True
else:
return False
def coming (self):
"""truck coming"""
if self.check_next_state_time():
self.truck_times["arrival"] = self.current_time
if self.current_door.check_door(self.element_name):
self.state += 2
self.next_state_time = self.current_time + self.changeover_time
else:
self.state += 1
self.next_state_time = -1
self.state_change = True
else:
pass
def next_state(self):
"""
called at every next state
"""
self.state += 1
self.state_change = True
def waiting_to_deploy (self):
"""waiting to deploy goods for inboudn and compound trucks"""
self.simulation_state = 1
if self.current_door.check_door(self.element_name):
self.truck_times["started entering receiving door"] = self.current_time
self.next_state()
self.next_state_time = self.current_time + self.changeover_time
def waiting_to_load (self):
"""
waiting to load for outbound and compound trucks
"""
self.simulation_state = 2
if self.current_door.check_door(self.element_name):
self.truck_times["started entering shipping door"] = self.current_time
self.next_state()
self.next_state_time = self.current_time + self.changeover_time
def changeover_load(self):
"""
changeover time for inbound and compound while loading
"""
self.simulation_state = 2
if self.check_next_state_time():
self.truck_times["at the shipping door"] = self.current_time
if self.station.good_store.check_enough(self.going_good_dict):
removed = self.station.good_store.remove_good(self.going_good_dict)
self.going_good_store.add_good_dict(removed)
self.state += 2
total_good = 0
self.truck_times["started loading"] = self.current_time
for good_amount in self.going_good_dict.values():
total_good += good_amount
self.next_state_time = self.current_time + self.good_loading_time * total_good
else:
self.state += 1
self.truck_times["not enough goods"] = self.current_time
self.next_state_time = -1
self.state_change = True
def changeover_deploy(self):
"""
changeover time for outbound and compound while deploying
"""
self.simulation_state = 1
if self.check_next_state_time():
self.truck_times["started deploying goods"] = self.current_time
self.next_state()
self.next_state_time = self.current_time + self.coming_good_store.calculate_total() * self.good_unloading_time
def changeover_fin(self):
"""
changeover after process finished for all trucks
"""
if self.check_next_state_time():
self.current_door.door_empty = True
self.truck_times["departed from the door"] = self.current_time
self.truck_times["done"] = self.current_time
self.next_state()
def changeover_mid(self):
"""
changeover at mid for compound trucks
"""
if self.check_next_state_time():
self.current_door.door_empty = True
self.current_door = self.second_door
self.truck_times["started going to shipping side"] = self.current_time
self.next_state_time = self.current_time + self.truck_transfer_time
self.next_state()
def not_enough_goods(self):
"""
waiting for enough goods to load
"""
if self.station.good_store.check_enough(self.going_good_dict):
removed = self.station.good_store.remove_good(self.going_good_dict)
self.going_good_store.add_good_dict(removed)
total_good = 0
for good_amount in self.going_good_dict.values():
total_good += good_amount
self.next_state_time = self.current_time + self.good_loading_time * total_good
self.truck_times["started loading"] = self.current_time
self.next_state()
def loading(self):
"""
waiting to load goods
"""
if self.check_next_state_time():
self.next_state_time = self.current_time + self.changeover_time
self.truck_times["finished loading"] = self.current_time
self.next_state()
def deploying(self):
"""
deploying for inbound and compound trucks
"""
if self.check_next_state_time():
self.current_door.transfer_finished = True
self.current_door.good_store.add_good_dict(self.coming_good_store.good_dictionary)
self.current_door.good_transfer_time = self.current_time + self.good_transfer_time
self.coming_good_store.reset_goods()
self.next_state_time = self.current_time + self.changeover_time
self.truck_times["finished deploying"] = self.current_time
self.next_state()
def done(self):
"""
done for all trucks set the done signal
"""
self.simulation_state = 3
class CompoundTruck(Truck):
"""
Compound truck object
"""
def __init__(self):
Truck.__init__(self)
self.behaviour_list = ['coming', 'waiting_to_deploy', 'changeover', 'deploying', 'changeover2',
'truck_transfer', 'waiting_to_load', 'changeover3', 'not_ready_to_load',
'ready_to_load', 'must_load', 'loading', 'changeover4', 'done']
self.current_state = 0
self.function_list = [self.coming, self.waiting, self.changeover, self.deploying, self.changeover2,
self.truck_transfer, self.waiting_to_load, self.changeover3, self.not_ready_to_load,
self.ready_to_load, self.must_load, self.loading, self.changeover4, self.done]
self.current_time = 0
self.good = GoodStore()
self.needed_goods = {}
self.transfer_time = 0
self.lower_bound = 0
self.upper_bound = 0
self.good_amount = 0
def waiting(self):
pass
def changeover(self):
if self.current_time == self.next_state_time:
self.next_state()
self.next_state_time = self.good.calculate_load_time() + self.current_time
self.current_door.next_state()
def deploying(self):
if self.current_time == self.next_state_time:
self.next_state_time = self.changeover_time + self.current_time
self.current_door.goods_list.append(copy.deepcopy(self.good))
self.current_door.good_times.append(self.current_time + self.current_door.good_transfer_time)
self.good.clear_goods()
self.current_door.next_state()
self.next_state()
def changeover2(self):
if self.current_time == self.next_state_time:
self.current_door.next_state()
self.next_state()
self.next_state_time = self.transfer_time + self.current_time
self.good = GoodStore()
def truck_transfer(self):
if self.current_time == self.next_state_time:
self.next_state()
def waiting_to_load(self):
pass
def changeover3(self):
if self.current_time == self.next_state_time:
self.next_state()
self.next_state_time = self.transfer_time + self.current_time
def not_ready_to_load(self):
self.good_amount = sum(self.needed_goods.values())
self.next_state_time = self.good_amount * self.good.loading_time + self.current_time - 1
# if self.lower_bound < self.next_state_time:
# self.next_state()
# self.current_door.next_state()
# elif self.next_state_time > self.upper_bound:
# self.current_door.next_state()
# self.next_state()
self.next_state()
self.current_door.next_state()
def ready_to_load(self):
self.next_state_time = self.good_amount * self.good.loading_time + self.current_time - 1
#if self.next_state_time >= self.upper_bound - self.changeover_time - 1:
self.next_state()
self.current_door.next_state()
def must_load(self):
self.next_state_time = self.good_amount * self.good.loading_time + self.current_time - 1
if self.current_door.good_ready:
self.next_state()
self.current_door.next_state()
def loading(self):
if self.current_time == self.next_state_time:
for goods in self.current_door.goods.good_list.values():
for good in goods:
self.good.add_good(good.good_name, good.amount, good.coming_truck_name)
self.current_door.goods.clear_goods()
self.current_door.next_state()
self.next_state_time = self.current_time + self.changeover_time - 1
self.next_state()
def changeover4(self):
if self.current_time == self.next_state_time:
self.next_state()
self.current_door.current_state = 0
self.finish_time = self.current_time
def done(self):
pass
class InboundTruck(Truck):
"""
inbound truck class
"""
def __init__(self, truck_data, inbound_data):
Truck.__init__(self, truck_data)
self.truck_type = 0
self.state_list = ('coming', 'waiting', 'start_deploy', 'deploying', 'done')
self.arrival_time = inbound_data['arrival_time']
self.mu = inbound_data['mu']
self.product_per_truck = inbound_data['product_per_truck']
self.inbound_gdj = 0
self.door_number = 0
self.receive_door = 0
self.coming_good_amounts = {}
self.bounds = 0
self.coming_goods = GoodStore()
def calculate_gdj(self):
self.calculate_twogd()
self.inbound_gdj = int(uniform(self.arrival_time, self.two_gdj))
self.finish_time = self.inbound_gdj
def load_gdj(self):
pass
def current_action(self, current_time):
self.log_truck()
self.current_time = current_time
if self.current_state == 0:
self.coming()
if self.current_state == 1:
self.waiting()
if self.current_state == 2:
self.start_deploy()
if self.current_state == 3:
self.deploy_goods()
if self.current_state == 4:
self.leaving()
def start_deploy(self):
logging.info('Truck {0} started unloading goods at {1}'.format(self.truck_name, self.current_time))
total = 0
logging.debug("----Deploy goods:")
total += self.coming_goods.total()
self.finish_time = int(self.current_time + total * self.loading_time)
logging.debug("----Finish time: {0}".format(self.finish_time))
self.next_state()
def deploy_goods(self):
if self.current_time == self.finish_time:
logging.info('Truck {0} finished unloading goods at {1}'.format(self.truck_name, self.current_time))
self.receiving_door.deploy_goods(self.coming_goods, self.current_time)
self.next_state()
def coming(self):
if self.current_time == self.inbound_gdj:
self.next_state()
def leaving(self):
pass
def waiting(self):
pass
def __init__(self):
Truck.__init__(self)
self.behaviour_list = ['coming', 'waiting_to_deploy', 'changeover', 'deploying', 'changeover2', 'done']
self.function_list = [self.coming, self.waiting, self.changeover, self.deploying, self.changeover2, self.done]
self.good = GoodStore()
from src.good_store import GoodStore
good_store = GoodStore()
good_store.add_good_type(0)
good_store.add_good_type(1)
good_store.add_good_type(3)
print(good_store.good_amounts)
print(good_store.good_dictionary)
good_store.add_good(50, 0, 'inbound0')
good_store.add_good(50, 0, 'inbound1')
print(good_store.good_amounts)
print(good_store.good_dictionary)
good_store.add_good(200, 2, 'inbound0')
good_store.add_good(200, 1, 'inbound0')
print(good_store.good_amounts)
print(good_store.good_dictionary)
remove_dict = {0: 100, 1: 200, 2:100}
removed = good_store.remove_good(remove_dict)
print(removed)
print(good_store.good_amounts)
print(good_store.good_dictionary)
for good_list in removed.values():
good_list.print_goods()
good_store.add_good_dict(removed)
print(good_store.good_amounts)
