def print_data( data = DataStore()):
f = open('show_data_template.txt')
src = Template(f.read())
d = {'number_of_inbound': data.number_of_inbound_trucks,
'number_of_outbound': data.number_of_outbound_trucks,
'number_of_compound': data.number_of_compound_trucks,
'number_of_receiving_doors': data.number_of_receiving_doors,
'number_of_shipping_doors': data.number_of_shipping_doors,
'number_of_goods': data.number_of_goods,
'changeover_time': data.changeover_time,
'loading_time': data.loading_time,
'makespan_factor': data.makespan_factor,
'transfer_time': data.transfer_time,
'good_transfer_time': data.good_transfer_time,
'inbound_arrival_time': data.inbound_arrival_time,
'outbound_arrival_time': data.outbound_arrival_time,
'data_set': data.data_set_list,
'arrivals': data.arrival_times,
'boundaries': data.boundaries,
'inbound_goods': data.inbound_goods,
'outbound_goods': data.outbound_goods,
'compound_goods': data.outbound_goods}
result = src.render(d)
return result
def set_data(self, solver_data=SolverData(), data=DataStore()):
self.new_model()
self.solver_data = solver_data
self.data = data
self.model.set_data(solver_data, data)
self.sequence_algorithms = SequenceAlgorithm(data)
self.sequence_algorithms.set_data_set_number(
solver_data.data_set_number, data)
def __init__(self, data=DataStore()):
QDialog.__init__(self)
self.data = data
self.setWindowTitle('Data Set Window')
self.setWindowModality(Qt.ApplicationModal)
self.setupComponents()
self.setupButtons()
self.setupComponents()
self.setupConnections()
self.setup_layout()
self.load_data()
def __init__(self, data=DataStore()):
QDialog.__init__(self)
self.data = data
self.inboundView = []
self.outboundView = []
self.compoundView = []
self.setWindowTitle('Truck Data Window')
self.setupComponents()
self.setGeometry(300, 400, 500, 500)
self.setWindowModality(Qt.ApplicationModal)
def __init__(self):
self.iteration_number = 0
self.solution_type = ""
self.solution_name = ""
self.model = Model()
self.solver_data = SolverData()
self.data = DataStore()
self.iteration_results = IterationResults()
self.sequence_list = SequenceList()
self.current_sequence = Sequence()
self.iteration_saved = False
def set_data(self, solver_data=SolverData(), data=DataStore()):
self.data = data
self.solver_data = solver_data
self.data_set_number = self.solver_data.data_set_number
self.time_limit = self.solver_data.time_limit
#print("Setting Data Set:", self.data_set_number)
self.station = Station()
for i in range(self.data.number_of_inbound_trucks):
name = 'inbound' + str(i)
truck = InboundTruck(name)
self.inbound_trucks[name] = truck
self.coming_trucks[name] = truck
self.all_trucks[name] = truck
for i in range(self.data.number_of_outbound_trucks):
name = 'outbound' + str(i)
truck = OutboundTruck(name)
self.outbound_trucks[name] = truck
self.going_trucks[name] = truck
self.all_trucks[name] = truck
for i in range(self.data.number_of_compound_trucks):
name = 'compound' + str(i)
truck = CompoundTruck(name)
self.compound_trucks[name] = truck
self.coming_trucks[name] = truck
self.going_trucks[name] = truck
truck.truck_transfer_time = data.truck_transfer_time
self.all_trucks[name] = truck
for i in range(self.data.number_of_receiving_doors):
name = 'receiving' + str(i)
door = ReceivingDoor(name)
self.receiving_doors[name] = door
door.station = self.station
self.all_doors[name] = door
self.element_list.append(door)
for i in range(self.data.number_of_shipping_doors):
name = 'shipping' + str(i)
door = ShippingDoor(name)
self.shipping_doors[name] = door
self.element_list.append(door)
self.all_doors[name] = door
for truck in self.all_trucks.values():
self.element_list.append(truck)
self.set_coming_times()
self.set_states()
self.set_goods()
def main():
global data_store, cwd, opened_file
data_store = DataStore(config.DATA_STORE)
cwd.append(data_store.root_directory)
os.system("clear")
print("\nType help to get help.\n")
COMMANDS = {
"help": [help, 0],
"create": [create, 1],
"del": [delete, 1],
"ls": [list_contents, 0],
"mkdir": [mkdir, 1],
"cd": [chdir, 1],
"mv": [move, 2],
"open": [open_file, 1],
"close": [close_file, 0],
"append": [write_append, 0],
"write": [write_at, 0],
"read": [read, 0],
"move-within": [move_within_file, 0],
"truncate": [truncate_file, 0],
"show-mem-map": [show_mem_map, 0],
"clear": [clear, 0],
"exit": [exit, 0]
}
while True:
cwd_path = "/" + "/".join(list(map(lambda d: d.name, cwd[1:])))
prompt = f"{cwd_path} - \u001b[32m({opened_file})\u001b[0m> " if opened_file \
else f"{cwd_path}> "
user_input = input(prompt).split(" ")
if user_input[0] == "": continue
if user_input[0] in COMMANDS:
command = COMMANDS[user_input[0]]
if len(user_input[1:]) == command[1]:
try: command[0](*user_input[1:])
except Exception as e: print(e)
else:
print(f"{user_input[0]} takes {command[1]} arguments, " \
f"{len(user_input[1:])} given.")
else:
print(f"Command not recognized {user_input[0]}, " \
"type help for help.")
def __init__(self, parent):
self.parent = None
self.data = DataStore()
self.scn = QGraphicsScene()
QGraphicsView.__init__(self, self.scn)
self.setup_station()
self.show()
self.fitInView(self.scn.itemsBoundingRect(), Qt.KeepAspectRatio)
self.door_positions = {}
self.truck_positions = {}
self.doors = {}
self.truck_states = {}
self.trucks = {}
self.doors = {}
self.station = None
self.pause = None
self.dialog = []
def __init__(self):
super(MainWindow, self).__init__()
self.setupUi(self)
self.data = DataStore()
self.solver_data = SolverData()
self.solver = Solver(self.data, self.solver_data)
self.update_data_table()
self.setup_data()
self.value_connections()
self.connections()
self.combobox_coming_sequence = []
self.combobox_going_sequence = []
self.statusBar().showMessage('Ready')
self.load_generated_data()
self.results = OrderedDict()
self.shoved_solution_name = ""
self.shoved_iteration = IterationResults()
self.shoved_solution = ModelResult()
self.shoved_iteration_number = 0
self.continue_solution = True
self.showing_result = []
self.result_times = {}
self.function_type = "normal"
self.solution_name = ""
self.solution_number = 0
self.sequence_solver = SequenceSolver()
self.solution_results = dict()
self.enter_sequence_widget = EnterSequenceWidget(self.data)
self.current_sequence = Sequence()
self.load_data()
self.simulationStartButton.setEnabled(False)
self.simulationStepForwardButton.setEnabled(False)
self.result_show_best_solution_button.setEnabled(False)
self.result_show_errors_button.setEnabled(False)
self.result_show_sequences_button.setEnabled(False)
self.result_show_trucktimes_button.setEnabled(False)
self.result_show_truckgoods_button.setEnabled(False)
self.run_simulation_button.setEnabled(False)
def __init__(self, data=DataStore()):
self.data = data
self.coming_sequence = []
self.going_sequence = []
self.coming_sequence_element = SequenceElement('receiving', self.data.number_of_receiving_doors)
self.going_sequence_element = SequenceElement('shipping', self.data.number_of_shipping_doors)
def __init__(self, data=DataStore()):
SequenceAlgorithm.__init__(self, data)
self.algorithm_name = "annealing"
def gams_writer(file_name, data_set_number, data=DataStore()):
f = open('gams_template.txt')
src = Template(f.read())
inbound_arrivals = []
outbound_arrivals = []
lower_boundaries = []
upper_boundaries = []
inbound_goods = chain(data.compound_coming_goods, data.inbound_goods)
outbound_goods = chain(data.compound_going_goods, data.outbound_goods)
for i in range(data.number_of_compound_trucks):
truck_name = 'compound' + str(i)
inbound_arrivals.append(
int(data.arrival_times[data_set_number][truck_name][0]))
outbound_arrivals.append(
int(data.arrival_times[data_set_number][truck_name][1]))
lower_boundaries.append(
int(data.boundaries[data_set_number][truck_name][0]))
upper_boundaries.append(
int(data.boundaries[data_set_number][truck_name][1]))
for i in range(data.number_of_inbound_trucks):
truck_name = 'inbound' + str(i)
inbound_arrivals.append(
int(data.arrival_times[data_set_number][truck_name]))
for i in range(data.number_of_outbound_trucks):
truck_name = 'outbound' + str(i)
outbound_arrivals.append(
int(data.arrival_times[data_set_number][truck_name]))
lower_boundaries.append(
int(data.boundaries[data_set_number][truck_name][0]))
upper_boundaries.append(
int(data.boundaries[data_set_number][truck_name][1]))
d = {
'number_of_inbound':
data.number_of_inbound_trucks + data.number_of_compound_trucks,
'number_of_outbound':
data.number_of_outbound_trucks + data.number_of_compound_trucks,
'number_of_compound': data.number_of_compound_trucks,
'compound_plus_one': data.number_of_compound_trucks + 1,
'changeover_time': int(data.changeover_time),
'product_transfer_time': int(data.good_transfer_time),
'transfer_time': int(data.transfer_time),
'number_of_goods': data.number_of_goods,
'number_of_receiving_doors': data.number_of_receiving_doors,
'number_of_shipping_doors': data.number_of_shipping_doors,
'inbound_arrivals': inbound_arrivals,
'outbound_arrivals': outbound_arrivals,
'lower_boundaries': lower_boundaries,
'upper_boundaries': upper_boundaries,
'inbound_goods': inbound_goods,
'outbound_goods': outbound_goods,
'good_numbers': range(0, data.number_of_goods)
}
result = src.render(d)
s = open(file_name, 'w')
s.write(result)
s.close()
def __init__(self, data=DataStore()):
"""
Initialize trucks, the station and get ready to solve
:return: nothing
"""
self.data = data
self.inbound_trucks = OrderedDict()
self.outbound_trucks = OrderedDict()
self.compound_trucks = OrderedDict()
self.inbound_data = {}
self.outbound_data = {}
self.compound_data = {}
self.truck_data = {}
self.number_of_goods = self.data.number_of_goods
self.number_of_inbound_trucks = self.data.number_of_inbound_trucks
self.number_of_outbound_trucks = self.data.number_of_outbound_trucks
self.number_of_compound_trucks = self.data.number_of_compound_trucks
self.number_of_trucks = self.data.number_of_inbound_trucks + self.data.number_of_outbound_trucks + self.data.number_of_compound_trucks
self.number_of_coming_trucks = self.data.number_of_inbound_trucks + self.data.number_of_compound_trucks
self.number_of_going_trucks = self.data.number_of_outbound_trucks + self.data.number_of_compound_trucks
self.truck_dictionary = {
'inbound': self.inbound_trucks,
'outbound': self.outbound_trucks,
'compound': self.compound_trucks
}
self.all_trucks = None
self.sequence_bool = False
self.solution_finish = False
self.number_of_shipping_doors = self.data.number_of_shipping_doors
self.number_of_receiving_doors = self.data.number_of_receiving_doors
self.alpha = 0
self.gamma = 0
self.tightness_factor = 0
self.inbound_mu = 0
self.outbound_mu = 0
self.product_per_inbound_truck = 0
self.product_per_outbound_truck = 0
# calculate data
self.calculate_mu()
self.calculate_product_per_truck()
self.finish = False
# create trucks
self.inbound_data['arrival_time'] = self.data.inbound_arrival_time
self.inbound_data['mu'] = self.inbound_mu
self.inbound_data['product_per_truck'] = self.product_per_inbound_truck
self.outbound_data['arrival_time'] = self.data.outbound_arrival_time
self.outbound_data['mu'] = self.outbound_mu
self.outbound_data[
'product_per_truck'] = self.product_per_outbound_truck
self.compound_data['arrival_time'] = self.data.inbound_arrival_time
self.compound_data['mu'] = self.inbound_mu
self.compound_data['transfer_time'] = self.data.transfer_time
self.compound_data[
'inbound_product_per_truck'] = self.product_per_inbound_truck
self.compound_data[
'outbound_product_per_truck'] = self.product_per_outbound_truck
self.truck_data['loading_time'] = self.data.loading_time
self.truck_data['changeover_time'] = self.data.changeover_time
self.truck_data[
'makespan_factor'] = self.data.makespan_factor # not used anthwere!!
self.truck_data['alpha'] = self.alpha
self.truck_data['gamma'] = self.gamma
self.truck_data['tightness_factor'] = self.tightness_factor
self.station = Station(self.data.good_transfer_time)
self.create_trucks()
self.current_data_set = 0
# init model solution
self.current_time = 0
self.time_step = 1
def __init__(self, data=DataStore()):
self.algorithm_name = ""
self.data_set_number = 0
self.data = data
self.arrivals = {}
self.sequence = Sequence(self.data)
def __init__(self, data=DataStore(), solver_data=SolverData()):
QObject.__init__(self)
self.data = data
self.solver_data = solver_data
self.annealing = Annealing(self.data)
self.current_iteration = 0
def new_data(self):
self.data = DataStore()
self.update_data_table()
self.value_connections()
self.setup_data()
