From 96430a4b6c3bd5b62432f1cddd72ad255b658ae5 Mon Sep 17 00:00:00 2001 From: hit_lu Date: Sun, 16 Jul 2023 23:19:34 +0800 Subject: [PATCH] =?UTF-8?q?=E5=90=AF=E5=8F=91=E5=BC=8F=E4=BA=A7=E7=BA=BF?= =?UTF-8?q?=E5=88=86=E9=85=8D?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- base_optimizer/optimizer_aggregation.py | 129 +++++++---------- base_optimizer/optimizer_common.py | 8 +- base_optimizer/optimizer_feederpriority.py | 2 +- base_optimizer/optimizer_hybridgenetic.py | 59 ++++---- base_optimizer/optimizer_scanbased.py | 57 ++++---- dataloader.py | 14 +- optimizer.py | 117 +++++++++++++--- optimizer_genetic.py | 13 +- optimizer_heuristic.py | 153 ++++++++++++++++++++- optimizer_spidermonkey.py | 11 ++ result_analysis.py | 76 ++++++---- 11 files changed, 439 insertions(+), 200 deletions(-) create mode 100644 optimizer_spidermonkey.py diff --git a/base_optimizer/optimizer_aggregation.py b/base_optimizer/optimizer_aggregation.py index 4e383df..c7ba874 100644 --- a/base_optimizer/optimizer_aggregation.py +++ b/base_optimizer/optimizer_aggregation.py @@ -1,15 +1,18 @@ from base_optimizer.optimizer_common import * -from ortools.sat.python import cp_model +from gurobipy import * from collections import defaultdict +def list_range(start, end=None): + return list(range(start)) if end is None else list(range(start, end)) + + @timer_wrapper def optimizer_aggregation(component_data, pcb_data): # === phase 0: data preparation === M = 1000 # a sufficient large number a, b = 1, 6 # coefficient - K, I, J, L = max_head_index, 0, 0, 0 # the maximum number of heads, component types, nozzle types and batch level component_list, nozzle_list = defaultdict(int), defaultdict(int) cpidx_2_part, nzidx_2_nozzle = {}, {} @@ -26,10 +29,11 @@ def optimizer_aggregation(component_data, pcb_data): nzidx_2_nozzle[len(nzidx_2_nozzle)] = nozzle nozzle_list[nozzle] += 1 - I, J = len(component_list.keys()), len(nozzle_list.keys()) - L = I + 1 - HC = [[M for _ in range(J)] for _ in range(I)] # the handing class when component i is handled by nozzle type j - # represent the nozzle-component compatibility + I, J = len(component_list.keys()), len(nozzle_list.keys()) # the maximum number of component types and nozzle types + L = I + 1 # the maximum number of batch level + K = max_head_index # the maximum number of heads + HC = [[M for _ in range(J)] for _ in range(I)] # represent the nozzle-component compatibility + for i in range(I): for _, item in enumerate(cpidx_2_part.items()): index, part = item @@ -41,105 +45,71 @@ def optimizer_aggregation(component_data, pcb_data): HC[index][j] = 0 # === phase 1: mathematical model solver === - model = cp_model.CpModel() - solver = cp_model.CpSolver() + mdl = Model('SMT') + mdl.setParam('OutputFlag', 0) # === Decision Variables === # the number of components of type i that are placed by nozzle type j on placement head k - X = {} - for i in range(I): - for j in range(J): - for k in range(K): - X[i, j, k] = model.NewIntVar(0, component_list[cpidx_2_part[i]], 'X_{}_{}_{}'.format(i, j, k)) + X = mdl.addVars(list_range(I), list_range(J), list_range(K), vtype=GRB.INTEGER, ub=max(component_list.values())) # the total number of nozzle changes on placement head k - N = {} - for k in range(K): - N[k] = model.NewIntVar(0, J, 'N_{}'.format(k)) + N = mdl.addVars(list_range(K), vtype=GRB.INTEGER) # the largest workload of all placement heads - WL = model.NewIntVar(0, len(pcb_data), 'WL') + WL = mdl.addVar(vtype=GRB.INTEGER, lb=0, ub=len(pcb_data)) # whether batch Xijk is placed on level l - Z = {} - for i in range(I): - for j in range(J): - for l in range(L): - for k in range(K): - Z[i, j, l, k] = model.NewBoolVar('Z_{}_{}_{}_{}'.format(i, j, l, k)) + Z = mdl.addVars(list_range(I), list_range(J), list_range(L), list_range(K), vtype=GRB.BINARY) # Dlk := 2 if a change of nozzles in the level l + 1 on placement head k # Dlk := 1 if there are no batches placed on levels higher than l - D = {} - for l in range(L): - for k in range(K): - D[l, k] = model.NewIntVar(0, 2, 'D_{}_{}'.format(l, k)) - - D_abs = {} - for l in range(L): - for j in range(J): - for k in range(K): - D_abs[l, j, k] = model.NewIntVar(0, M, 'D_abs_{}_{}_{}'.format(l, j, k)) + # Dlk := 0 otherwise + D = mdl.addVars(list_range(L), list_range(K), vtype=GRB.BINARY, ub=2) + D_plus = mdl.addVars(list_range(L), list_range(J), list_range(K), vtype=GRB.INTEGER) + D_minus = mdl.addVars(list_range(L), list_range(J), list_range(K), vtype=GRB.INTEGER) # == Objective function === - model.Minimize(a * WL + b * sum(N[k] for k in range(K))) + mdl.modelSense = GRB.MINIMIZE + mdl.setObjective(a * WL + b * quicksum(N[k] for k in range(K))) # === Constraint === - for i in range(I): - model.Add(sum(X[i, j, k] for j in range(J) for k in range(K)) == component_list[cpidx_2_part[i]]) + mdl.addConstrs( + quicksum(X[i, j, k] for j in range(J) for k in range(K)) == component_list[cpidx_2_part[i]] for i in range(I)) - for k in range(K): - model.Add(sum(X[i, j, k] for i in range(I) for j in range(J)) <= WL) + mdl.addConstrs(quicksum(X[i, j, k] for i in range(I) for j in range(J)) <= WL for k in range(K)) - for i in range(I): - for j in range(J): - for k in range(K): - model.Add(X[i, j, k] <= M * sum(Z[i, j, l, k] for l in range(L))) + mdl.addConstrs( + X[i, j, k] <= M * quicksum(Z[i, j, l, k] for l in range(L)) for i in range(I) for j in range(J) for k in + range(K)) - for i in range(I): - for j in range(J): - for k in range(K): - model.Add(sum(Z[i, j, l, k] for l in range(L)) <= 1) + mdl.addConstrs(quicksum(Z[i, j, l, k] for l in range(L)) <= 1 for i in range(I) for j in range(J) for k in range(K)) + mdl.addConstrs( + quicksum(Z[i, j, l, k] for l in range(L)) <= X[i, j, k] for i in range(I) for j in range(J) for k in range(K)) - for i in range(I): - for j in range(J): - for k in range(K): - model.Add(sum(Z[i, j, l, k] for l in range(L)) <= X[i, j, k]) + mdl.addConstrs(quicksum(Z[i, j, l, k] for j in range(J) for i in range(I)) >= quicksum( + Z[i, j, l + 1, k] for j in range(J) for i in range(I)) for k in range(K) for l in range(L - 1)) - for k in range(K): - for l in range(L - 1): - model.Add(sum(Z[i, j, l, k] for j in range(J) for i in range(I)) >= sum( - Z[i, j, l + 1, k] for j in range(J) for i in range(I))) + mdl.addConstrs(quicksum(Z[i, j, l, k] for i in range(I) for j in range(J)) <= 1 for k in range(K) for l in range(L)) + mdl.addConstrs(D_plus[l, j, k] - D_minus[l, j, k] == quicksum(Z[i, j, l, k] for i in range(I)) - quicksum( + Z[i, j, l + 1, k] for i in range(I)) for l in range(L - 1) for j in range(J) for k in range(K)) - for l in range(I): - for k in range(K): - model.Add(sum(Z[i, j, l, k] for i in range(I) for j in range(J)) <= 1) + mdl.addConstrs( + D[l, k] == quicksum((D_plus[l, j, k] + D_minus[l, j, k]) for j in range(J)) for k in range(K) for l in + range(L)) - for l in range(L - 1): - for j in range(J): - for k in range(K): - model.AddAbsEquality(D_abs[l, j, k], - sum(Z[i, j, l, k] for i in range(I)) - sum(Z[i, j, l + 1, k] for i in range(I))) - - for k in range(K): - for l in range(L): - model.Add(D[l, k] == sum(D_abs[l, j, k] for j in range(J))) - - for k in range(K): - model.Add(N[k] == sum(D[l, k] for l in range(L)) - 1) - - for l in range(L): - for k in range(K): - model.Add(0 >= sum(HC[i][j] * Z[i, j, l, k] for i in range(I) for j in range(J))) + mdl.addConstrs(2 * N[k] == quicksum(D[l, k] for l in range(L)) - 1 for k in range(K)) + mdl.addConstrs( + 0 >= quicksum(HC[i][j] * Z[i, j, l, k] for i in range(I) for j in range(J)) for l in range(L) for k in range(K)) # === Main Process === component_result, cycle_result = [], [] feeder_slot_result, placement_result, head_sequence = [], [], [] - solver.parameters.max_time_in_seconds = 20.0 + mdl.setParam("TimeLimit", 100) - status = solver.Solve(model) - if status == cp_model.OPTIMAL or status == cp_model.FEASIBLE: - print('total cost = {}'.format(solver.ObjectiveValue())) + mdl.optimize() + + if mdl.Status == GRB.OPTIMAL: + print('total cost = {}'.format(mdl.objval)) # convert cp model solution to standard output model_cycle_result, model_component_result = [], [] @@ -149,9 +119,9 @@ def optimizer_aggregation(component_data, pcb_data): for k in range(K): for i in range(I): for j in range(J): - if solver.BooleanValue(Z[i, j, l, k]) != 0: + if abs(Z[i, j, l, k].x - 1) <= 1e-3: model_component_result[-1][k] = cpidx_2_part[i] - model_cycle_result[-1][k] = solver.Value(X[i, j, k]) + model_cycle_result[-1][k] = round(X[i, j, k].x) # remove redundant term if sum(model_cycle_result[-1]) == 0: @@ -209,7 +179,6 @@ def optimizer_aggregation(component_data, pcb_data): if component_result[cycle_idx][head] == -1: continue index_ = component_result[cycle_idx][head] - placement_result[-1][head] = mount_point_pos[index_][-1][2] mount_point_pos[index_].pop() head_sequence.append(dynamic_programming_cycle_path(pcb_data, placement_result[-1], feeder_slot_result[cycle_idx])) diff --git a/base_optimizer/optimizer_common.py b/base_optimizer/optimizer_common.py index 95a1d68..9307366 100644 --- a/base_optimizer/optimizer_common.py +++ b/base_optimizer/optimizer_common.py @@ -49,6 +49,12 @@ feeder_width = {'SM8': (7.25, 7.25), 'SM12': (7.00, 20.00), 'SM16': (7.00, 22.00 # 可用吸嘴数量限制 nozzle_limit = {'CN065': 6, 'CN040': 6, 'CN220': 6, 'CN400': 6, 'CN140': 6} +# 时间参数 +t_cycle = 0.3 +t_pick, t_place = .078, .051 # 贴装/拾取用时 +t_nozzle_put, t_nozzle_pick = 0.9, 0.75 # 装卸吸嘴用时 +t_nozzle_change = t_nozzle_put + t_nozzle_pick +t_fix_camera_check = 0.12 # 固定相机检测时间 def axis_moving_time(distance, axis=0): distance = abs(distance) * 1e-3 @@ -880,7 +886,7 @@ def constraint_swap_mutation(component_points, individual): offspring = individual.copy() idx, component_index = 0, random.randint(0, len(component_points) - 1) - for points in component_points.values(): + for _, points in component_points: if component_index == 0: while True: index1, index2 = random.sample(range(points + max_machine_index - 2), 2) diff --git a/base_optimizer/optimizer_feederpriority.py b/base_optimizer/optimizer_feederpriority.py index 2dbb071..5d27d46 100644 --- a/base_optimizer/optimizer_feederpriority.py +++ b/base_optimizer/optimizer_feederpriority.py @@ -2,7 +2,7 @@ from base_optimizer.optimizer_common import * @timer_wrapper -def feeder_allocate(component_data, pcb_data, feeder_data, nozzle_pattern, figure=False): +def feeder_allocate(component_data, pcb_data, feeder_data, figure=False): feeder_points, feeder_division_points = defaultdict(int), defaultdict(int) # 供料器贴装点数 mount_center_pos = defaultdict(int) diff --git a/base_optimizer/optimizer_hybridgenetic.py b/base_optimizer/optimizer_hybridgenetic.py index 609be78..f740508 100644 --- a/base_optimizer/optimizer_hybridgenetic.py +++ b/base_optimizer/optimizer_hybridgenetic.py @@ -234,8 +234,8 @@ def cal_individual_val(component_nozzle, component_point_pos, designated_nozzle, return V[-1], pickup_result, pickup_cycle_result -def convert_individual_2_result(component_data, component_point_pos, designated_nozzle, pickup_group, pickup_group_cycle, - pair_group, feeder_lane, individual): +def convert_individual_2_result(component_data, component_point_pos, designated_nozzle, pickup_group, + pickup_group_cycle, pair_group, feeder_lane, individual): component_result, cycle_result, feeder_slot_result = [], [], [] placement_result, head_sequence_result = [], [] @@ -418,19 +418,19 @@ def optimizer_hybrid_genetic(pcb_data, component_data, hinter=True): pick_part = pickup[pickup_index] # 检查槽位占用情况 - if feeder_lane[slot] is not None and pick_part is not None: + if feeder_lane[slot] and pick_part: assign_available = False break # 检查机械限位冲突 - if pick_part is not None and (slot - CT_Head[pick_part][0] * interval_ratio <= 0 or - slot + (max_head_index - CT_Head[pick_part][1] - 1) * interval_ratio > max_slot_index // 2): + if pick_part and (slot - CT_Head[pick_part][0] * interval_ratio <= 0 or slot + ( + max_head_index - CT_Head[pick_part][1] - 1) * interval_ratio > max_slot_index // 2): assign_available = False break if assign_available: for idx, component in enumerate(pickup): - if component is not None: + if component: feeder_lane[assign_slot + idx * interval_ratio] = component CT_Group_slot[CTIdx] = assign_slot break @@ -509,32 +509,31 @@ def optimizer_hybrid_genetic(pcb_data, component_data, hinter=True): with tqdm(total=n_generations) as pbar: pbar.set_description('hybrid genetic process') + # calculate fitness value + pop_val = [] + for pop_idx, individual in enumerate(population): + val, _, _ = cal_individual_val(component_nozzle, component_point_pos, designated_nozzle, pickup_group, + pickup_group_cycle, pair_group, feeder_part_arrange, individual) + pop_val.append(val) # val is related to assembly time for _ in range(n_generations): - # calculate fitness value - pop_val = [] - for pop_idx, individual in enumerate(population): - val, _, _ = cal_individual_val(component_nozzle, component_point_pos, designated_nozzle, pickup_group, - pickup_group_cycle, pair_group, feeder_part_arrange, individual) - pop_val.append(val) - - idx = np.argmin(pop_val) - if len(best_pop_val) == 0 or pop_val[idx] < best_pop_val[-1]: - best_individual = copy.deepcopy(population[idx]) - best_pop_val.append(pop_val[idx]) + # idx = np.argmin(pop_val) + # if len(best_pop_val) == 0 or pop_val[idx] < best_pop_val[-1]: + # best_individual = copy.deepcopy(population[idx]) + # best_pop_val.append(pop_val[idx]) # min-max convert max_val = 1.5 * max(pop_val) - pop_val = list(map(lambda v: max_val - v, pop_val)) + convert_pop_val = list(map(lambda v: max_val - v, pop_val)) # crossover and mutation c = 0 - new_population = [] + new_population, new_pop_val = [], [] for pop in range(population_size): if pop % 2 == 0 and np.random.random() < crossover_rate: - index1, index2 = roulette_wheel_selection(pop_val), -1 + index1, index2 = roulette_wheel_selection(convert_pop_val), -1 while True: - index2 = roulette_wheel_selection(pop_val) + index2 = roulette_wheel_selection(convert_pop_val) if index1 != index2: break # 两点交叉算子 @@ -552,13 +551,27 @@ def optimizer_hybrid_genetic(pcb_data, component_data, hinter=True): new_population.append(offspring1) new_population.append(offspring2) - # selection - top_k_index = get_top_k_value(pop_val, population_size - len(new_population)) + val, _, _ = cal_individual_val(component_nozzle, component_point_pos, designated_nozzle, + pickup_group, + pickup_group_cycle, pair_group, feeder_part_arrange, offspring1) + new_pop_val.append(val) + + val, _, _ = cal_individual_val(component_nozzle, component_point_pos, designated_nozzle, + pickup_group, + pickup_group_cycle, pair_group, feeder_part_arrange, offspring2) + new_pop_val.append(val) + + # generate next generation + top_k_index = get_top_k_value(pop_val, population_size - len(new_population), reverse=False) for index in top_k_index: new_population.append(population[index]) + new_pop_val.append(pop_val[index]) population = new_population + pop_val = new_pop_val pbar.update(1) + best_individual = population[np.argmin(pop_val)] + return convert_individual_2_result(component_data, component_point_pos, designated_nozzle, pickup_group, pickup_group_cycle, pair_group, feeder_lane, best_individual) diff --git a/base_optimizer/optimizer_scanbased.py b/base_optimizer/optimizer_scanbased.py index d6a9cc3..6f4c12b 100644 --- a/base_optimizer/optimizer_scanbased.py +++ b/base_optimizer/optimizer_scanbased.py @@ -3,11 +3,11 @@ from base_optimizer.optimizer_common import * @timer_wrapper -def optimizer_scanbased(component_data, pcb_data, hinter): +def optimizer_genetic_scanning(component_data, pcb_data, hinter): population_size = 200 # 种群规模 crossover_rate, mutation_rate = .4, .02 - n_generation = 5 + n_generation = 500 component_points = [0] * len(component_data) for i in range(len(pcb_data)): @@ -31,49 +31,51 @@ def optimizer_scanbased(component_data, pcb_data, hinter): pop_val.append(feeder_arrange_evaluate(feeder_slot_result, cycle_result)) - # todo: 过程写的有问题，暂时不想改 + sigma_scaling(pop_val, 1) + with tqdm(total=n_generation) as pbar: pbar.set_description('hybrid genetic process') + new_pop_val, new_pop_individual = [], [] + + # min-max convert + max_val = 1.5 * max(pop_val) + convert_pop_val = list(map(lambda v: max_val - v, pop_val)) for _ in range(n_generation): # 交叉 for pop in range(population_size): if pop % 2 == 0 and np.random.random() < crossover_rate: - index1, index2 = roulette_wheel_selection(pop_val), -1 + index1, index2 = roulette_wheel_selection(convert_pop_val), -1 while True: - index2 = roulette_wheel_selection(pop_val) + index2 = roulette_wheel_selection(convert_pop_val) if index1 != index2: break # 两点交叉算子 offspring1, offspring2 = cycle_crossover(pop_individual[index1], pop_individual[index2]) + # 变异 + if np.random.random() < mutation_rate: + offspring1 = swap_mutation(offspring1) + + if np.random.random() < mutation_rate: + offspring2 = swap_mutation(offspring2) + _, cycle_result, feeder_slot_result = convert_individual_2_result(component_points, offspring1) - pop_val.append(feeder_arrange_evaluate(feeder_slot_result, cycle_result)) - pop_individual.append(offspring1) + new_pop_val.append(feeder_arrange_evaluate(feeder_slot_result, cycle_result)) + new_pop_individual.append(offspring1) _, cycle_result, feeder_slot_result = convert_individual_2_result(component_points, offspring2) - pop_val.append(feeder_arrange_evaluate(feeder_slot_result, cycle_result)) - pop_individual.append(offspring2) + new_pop_val.append(feeder_arrange_evaluate(feeder_slot_result, cycle_result)) + new_pop_individual.append(offspring2) - sigma_scaling(pop_val, 1) + # generate next generation + top_k_index = get_top_k_value(pop_val, population_size - len(new_pop_individual), reverse=False) + for index in top_k_index: + new_pop_individual.append(pop_individual[index]) + new_pop_val.append(pop_val[index]) - # 变异 - if np.random.random() < mutation_rate: - index_ = roulette_wheel_selection(pop_val) - offspring = swap_mutation(pop_individual[index_]) - _, cycle_result, feeder_slot_result = convert_individual_2_result(component_points, offspring) - - pop_val.append(feeder_arrange_evaluate(feeder_slot_result, cycle_result)) - pop_individual.append(offspring) - - sigma_scaling(pop_val, 1) - - new_population, new_popval = [], [] - for index in get_top_k_value(pop_val, population_size): - new_population.append(pop_individual[index]) - new_popval.append(pop_val[index]) - - pop_individual, pop_val = new_population, new_popval + pop_individual, pop_val = new_pop_individual, new_pop_val + sigma_scaling(pop_val, 1) # select the best individual pop = np.argmin(pop_val) @@ -98,7 +100,6 @@ def convert_individual_2_result(component_points, pop): feeder_part[gene], feeder_base_points[gene] = idx, component_points[idx] # TODO: 暂时未考虑可用吸嘴数的限制 - # for _ in range(math.ceil(sum(component_points) / max_head_index)): while True: # === 周期内循环 === assigned_part = [-1 for _ in range(max_head_index)] # 当前扫描到的头分配元件信息 diff --git a/dataloader.py b/dataloader.py index e73e200..dd91718 100644 --- a/dataloader.py +++ b/dataloader.py @@ -27,7 +27,7 @@ def load_data(filename: str, default_feeder_limit=1, load_cp_data=True, load_fee # 注册元件检查 part_feeder_assign = defaultdict(set) - part_col = ["part", "desc", "fdr", "nz", 'camera', 'group', 'feeder-limit'] + part_col = ["part", "desc", "fdr", "nz", 'camera', 'group', 'feeder-limit', 'points'] try: if load_cp_data: component_data = pd.DataFrame(pd.read_csv(filepath_or_buffer='component.txt', sep='\t', header=None), @@ -40,18 +40,18 @@ def load_data(filename: str, default_feeder_limit=1, load_cp_data=True, load_fee for _, data in pcb_data.iterrows(): part, nozzle = data.part, data.nz.split(' ')[1] slot = data['fdr'].split(' ')[0] - if part not in component_data['part'].values: if not cp_auto_register: raise Exception("unregistered component: " + component_data['part'].values) else: component_data = pd.concat([component_data, pd.DataFrame( - [part, '', 'SM8', nozzle, '飞行相机1', 'CHIP-Rect', default_feeder_limit], index=part_col).T], + [part, '', 'SM8', nozzle, '飞行相机1', 'CHIP-Rect', default_feeder_limit, 0], index=part_col).T], ignore_index=True) # warning_info = 'register component ' + part + ' with default feeder type' # warnings.warn(warning_info, UserWarning) part_index = component_data[component_data['part'] == part].index.tolist()[0] part_feeder_assign[part].add(slot) + component_data.loc[part_index]['points'] += 1 if nozzle != 'A' and component_data.loc[part_index]['nz'] != nozzle: warning_info = 'the nozzle type of component ' + part + ' is not consistent with the pcb data' @@ -64,9 +64,8 @@ def load_data(filename: str, default_feeder_limit=1, load_cp_data=True, load_fee # 读取供料器基座数据 feeder_data = pd.DataFrame(columns=['slot', 'part', 'arg']) # arg表示是否为预分配，不表示分配数目 if load_feeder_data: - for data in pcb_data.iterrows(): - fdr = data[1]['fdr'] - slot, part = fdr.split(' ') + for _, data in pcb_data.iterrows(): + slot, part = data['fdr'].split(' ') if slot[0] != 'F' and slot[0] != 'R': continue slot = int(slot[1:]) if slot[0] == 'F' else int(slot[1:]) + max_slot_index // 2 @@ -80,6 +79,5 @@ def load_data(filename: str, default_feeder_limit=1, load_cp_data=True, load_fee feeder_data.sort_values(by='slot', ascending=True, inplace=True, ignore_index=True) - # plt.scatter(pcb_data["x"], pcb_data["y"]) - # plt.show() + pcb_data = pcb_data.sort_values(by="x", ascending=False) return pcb_data, component_data, feeder_data diff --git a/optimizer.py b/optimizer.py index 5cfa5ec..0418f74 100644 --- a/optimizer.py +++ b/optimizer.py @@ -1,3 +1,4 @@ +import copy import math import matplotlib.pyplot as plt @@ -15,10 +16,21 @@ from optimizer_genetic import * from optimizer_heuristic import * -def optimizer(pcb_data, component_data, assembly_line_optimizer, single_machine_optimizer): - assignment_result = assemblyline_optimizer_genetic(pcb_data, component_data) +def deviation(data): + assert len(data) > 0 + average, variance = sum(data) / len(data), 0 + for v in data: + variance += (v - average) ** 2 + return variance / len(data) - # assignment_result = [[0, 0, 0, 0, 216, 0, 0], [0, 0, 0, 0, 216, 0, 0], [36, 24, 12, 12, 0, 36, 12]] + +def optimizer(pcb_data, component_data, assembly_line_optimizer, single_machine_optimizer): + # todo: 由于吸嘴更换更因素的存在，在处理PCB8数据时，遗传算法因在负载均衡过程中对这一因素进行了考虑，性能更优 + assignment_result = assemblyline_optimizer_heuristic(pcb_data, component_data) + # assignment_result = assemblyline_optimizer_genetic(pcb_data, component_data) + print(assignment_result) + + assignment_result_cpy = copy.deepcopy(assignment_result) placement_points, placement_time = [], [] partial_pcb_data, partial_component_data = defaultdict(pd.DataFrame), defaultdict(pd.DataFrame) for machine_index in range(max_machine_index): @@ -26,7 +38,9 @@ def optimizer(pcb_data, component_data, assembly_line_optimizer, single_machine_ partial_component_data[machine_index] = component_data.copy(deep=True) placement_points.append(sum(assignment_result[machine_index])) - # averagely assign available feeder + assert sum(placement_points) == len(pcb_data) + + # === averagely assign available feeder === for part_index, data in component_data.iterrows(): feeder_limit = data['feeder-limit'] feeder_points = [assignment_result[machine_index][part_index] for machine_index in range(max_machine_index)] @@ -49,11 +63,14 @@ def optimizer(pcb_data, component_data, assembly_line_optimizer, single_machine_ partial_component_data[machine_index].loc[part_index]['feeder-limit'] += 1 feeder_limit -= 1 + for machine_index in range(max_machine_index): + if feeder_points[machine_index] > 0: + assert partial_component_data[machine_index].loc[part_index]['feeder-limit'] > 0 + + # === assign placements === component_machine_index = [0 for _ in range(len(component_data))] - pcb_data = pcb_data.sort_values(by="x", ascending=False) for _, data in pcb_data.iterrows(): - part = data['part'] - part_index = component_data[component_data['part'] == part].index.tolist()[0] + part_index = component_data[component_data['part'] == data['part']].index.tolist()[0] while True: machine_index = component_machine_index[part_index] if assignment_result[machine_index][part_index] == 0: @@ -64,11 +81,60 @@ def optimizer(pcb_data, component_data, assembly_line_optimizer, single_machine_ assignment_result[machine_index][part_index] -= 1 partial_pcb_data[machine_index] = pd.concat([partial_pcb_data[machine_index], pd.DataFrame(data).T]) + # === adjust the number of available feeders for single optimization separately === for machine_index, data in partial_pcb_data.items(): data = data.reset_index(drop=True) if len(data) == 0: continue + part_info = [] # part info list：(part index, part points, available feeder-num, upper feeder-num) + for part_index, cp_data in partial_component_data[machine_index].iterrows(): + if assignment_result_cpy[machine_index][part_index]: + part_info.append( + [part_index, assignment_result_cpy[machine_index][part_index], 1, cp_data['feeder-limit']]) + + part_info = sorted(part_info, key=lambda x: x[1], reverse=True) + start_index, end_index = 0, min(max_head_index - 1, len(part_info) - 1) + while start_index < len(part_info): + assign_part_point, assign_part_index = [], [] + for idx_ in range(start_index, end_index + 1): + for _ in range(part_info[idx_][2]): + assign_part_point.append(part_info[idx_][1] / part_info[idx_][2]) + assign_part_index.append(idx_) + + variance = deviation(assign_part_point) + while start_index != end_index: + part_info_index = assign_part_index[np.argmax(assign_part_point)] + + if part_info[part_info_index][2] < part_info[part_info_index][3]: # 供料器数目上限的限制 + part_info[part_info_index][2] += 1 + end_index -= 1 + + new_assign_part_point, new_assign_part_index = [], [] + for idx_ in range(start_index, end_index + 1): + for _ in range(part_info[idx_][2]): + new_assign_part_point.append(part_info[idx_][1] / part_info[idx_][2]) + new_assign_part_index.append(idx_) + + new_variance = deviation(new_assign_part_point) + if variance < new_variance: + part_info[part_info_index][2] -= 1 + end_index += 1 + break + + variance = new_variance + assign_part_index, assign_part_point = new_assign_part_index, new_assign_part_point + else: + break + + start_index = end_index + 1 + end_index = min(start_index + max_head_index - 1, len(part_info) - 1) + + # update available feeder number + max_avl_feeder = max(part_info, key=lambda x: x[2])[2] + for info in part_info: + partial_component_data[machine_index].loc[info[0]]['feeder-limit'] = math.ceil(info[2] / max_avl_feeder) + placement_time.append(base_optimizer(machine_index + 1, data, partial_component_data[machine_index], feeder_data=pd.DataFrame(columns=['slot', 'part', 'arg']), method=single_machine_optimizer, hinter=True)) @@ -86,13 +152,15 @@ def optimizer(pcb_data, component_data, assembly_line_optimizer, single_machine_ # todo: 不同类型元件的组装时间差异 def base_optimizer(machine_index, pcb_data, component_data, feeder_data=None, method='', hinter=False): + if method == 'cell_division': # 基于元胞分裂的遗传算法 - component_result, cycle_result, feeder_slot_result = optimizer_celldivision(pcb_data, component_data, False) + component_result, cycle_result, feeder_slot_result = optimizer_celldivision(pcb_data, component_data, + hinter=False) placement_result, head_sequence = greedy_placement_route_generation(component_data, pcb_data, component_result, cycle_result, feeder_slot_result) - elif method == 'feeder_priority': # 基于基座扫描的供料器优先算法 + elif method == 'feeder_scan': # 基于基座扫描的供料器优先算法 # 第1步：分配供料器位置 - nozzle_pattern = feeder_allocate(component_data, pcb_data, feeder_data, False) + nozzle_pattern = feeder_allocate(component_data, pcb_data, feeder_data, figure=False) # 第2步：扫描供料器基座，确定元件拾取的先后顺序 component_result, cycle_result, feeder_slot_result = feeder_base_scan(component_data, pcb_data, feeder_data, nozzle_pattern) @@ -105,25 +173,26 @@ def base_optimizer(machine_index, pcb_data, component_data, feeder_data=None, me elif method == 'hybrid_genetic': # 基于拾取组的混合遗传算法 component_result, cycle_result, feeder_slot_result, placement_result, head_sequence = optimizer_hybrid_genetic( - pcb_data, component_data, False) + pcb_data, component_data, hinter=False) elif method == 'aggregation': # 基于batch-level的整数规划 + 启发式算法 component_result, cycle_result, feeder_slot_result, placement_result, head_sequence = optimizer_aggregation( component_data, pcb_data) - elif method == 'scan_based': - component_result, cycle_result, feeder_slot_result, placement_result, head_sequence = optimizer_scanbased( - component_data, pcb_data, False) + elif method == 'genetic_scanning': + component_result, cycle_result, feeder_slot_result, placement_result, head_sequence = optimizer_genetic_scanning( + component_data, pcb_data, hinter=False) else: raise 'method is not existed' if hinter: optimization_assign_result(component_data, pcb_data, component_result, cycle_result, feeder_slot_result, - nozzle_hinter=False, component_hinter=False, feeder_hinter=False) + nozzle_hinter=True, component_hinter=False, feeder_hinter=False) print('----- Placement machine ' + str(machine_index) + ' ----- ') print('-Cycle counter: {}'.format(sum(cycle_result))) total_nozzle_change_counter, total_pick_counter = 0, 0 + total_pick_movement = 0 assigned_nozzle = ['' if idx == -1 else component_data.loc[idx]['nz'] for idx in component_result[0]] for cycle in range(len(cycle_result)): @@ -141,25 +210,31 @@ def base_optimizer(machine_index, pcb_data, component_data, feeder_data=None, me pick_slot.add(feeder_slot_result[cycle][head] - head * interval_ratio) total_pick_counter += len(pick_slot) * cycle_result[cycle] + pick_slot = list(pick_slot) + pick_slot.sort() + for idx in range(len(pick_slot) - 1): + total_pick_movement += abs(pick_slot[idx+1] - pick_slot[idx]) + print('-Nozzle change counter: {}'.format(total_nozzle_change_counter)) print('-Pick operation counter: {}'.format(total_pick_counter)) + print('-Pick movement: {}'.format(total_pick_movement)) print('------------------------------ ') # 估算贴装用时 return placement_time_estimate(component_data, pcb_data, component_result, cycle_result, feeder_slot_result, - placement_result, head_sequence, False) + placement_result, head_sequence, hinter=False) +@timer_wrapper def main(): # warnings.simplefilter('ignore') # 参数解析 parser = argparse.ArgumentParser(description='assembly line optimizer implementation') - parser.add_argument('--filename', default='PCB1 - FL19-30W.txt', type=str, help='load pcb data') + parser.add_argument('--filename', default='PCB.txt', type=str, help='load pcb data') parser.add_argument('--auto_register', default=1, type=int, help='register the component according the pcb data') - parser.add_argument('--base_optimizer', default='feeder_priority', type=str, - help='base optimizer for single machine') - parser.add_argument('--assembly_optimizer', default='genetic', type=str, help='optimizer for PCB Assembly Line') - parser.add_argument('--feeder_limit', default=2, type=int, + parser.add_argument('--base_optimizer', default='feeder_scan', type=str, help='base optimizer for single machine') + parser.add_argument('--assembly_optimizer', default='heuristic', type=str, help='optimizer for PCB Assembly Line') + parser.add_argument('--feeder_limit', default=3, type=int, help='the upper feeder limit for each type of component') params = parser.parse_args() diff --git a/optimizer_genetic.py b/optimizer_genetic.py index d25e679..5771408 100644 --- a/optimizer_genetic.py +++ b/optimizer_genetic.py @@ -1,14 +1,14 @@ +# implementation of <> import matplotlib.pyplot as plt from base_optimizer.optimizer_common import * def selective_initialization(component_points, component_feeders, population_size): - population = [] # population initialization - + population = [] # population initialization for _ in range(population_size): individual = [] - for part_index, points in component_points.items(): + for part_index, points in component_points: if points == 0: continue # 可用机器数 @@ -50,7 +50,7 @@ def selective_crossover(component_points, component_feeders, mother, father, non one_counter, feasible_cut_line = 0, [] idx = 0 - for part_index, points in component_points.items(): + for part_index, points in component_points: one_counter = 0 idx_, mother_cut_line, father_cut_line = 0, [-1], [-1] @@ -136,7 +136,7 @@ def cal_individual_val(component_points, component_nozzle, individual): machine_component_points = [[] for _ in range(max_machine_index)] # decode the component allocation - for points in component_points.values(): + for _, points in component_points: component_gene = individual[idx: idx + points + max_machine_index - 1] machine_idx, component_counter = 0, 0 for gene in component_gene: @@ -206,6 +206,7 @@ def assemblyline_optimizer_genetic(pcb_data, component_data): # crossover rate & mutation rate: 80% & 10% # population size: 200 # the number of generation: 500 + np.random.seed(0) crossover_rate, mutation_rate = 0.8, 0.1 population_size, n_generations = 200, 500 @@ -219,6 +220,8 @@ def assemblyline_optimizer_genetic(pcb_data, component_data): component_feeders[part_index] = component_data.loc[part_index]['feeder-limit'] component_nozzle[part_index] = nozzle + component_points = sorted(component_points.items(), key=lambda x: x[0]) # 决定染色体排列顺序 + # population initialization best_popval = [] population = selective_initialization(component_points, component_feeders, population_size) diff --git a/optimizer_heuristic.py b/optimizer_heuristic.py index 3ca559f..c5584ad 100644 --- a/optimizer_heuristic.py +++ b/optimizer_heuristic.py @@ -1,16 +1,157 @@ +import math +import numpy as np + from base_optimizer.optimizer_common import * +from ortools.sat.python import cp_model -# TODO: 需要考虑贴装点分布位置的限制 -def assembly_time_estimator(pcb_data, component_data, assignment): - return 0 +# TODO: consider with the PCB placement topology +def assembly_time_estimator(component_points, component_feeders, component_nozzle, assignment_points): + # todo: how to deal with nozzle change + n_cycle, n_nz_change, n_gang_pick = 0, 0, 0 + + nozzle_heads, nozzle_points = defaultdict(int), defaultdict(int) + for idx, points in enumerate(assignment_points): + if points == 0: + continue + nozzle_points[component_nozzle[idx]] += points + nozzle_heads[component_nozzle[idx]] = 1 + + while sum(nozzle_heads.values()) != max_head_index: + max_cycle_nozzle = None + + for nozzle, head_num in nozzle_heads.items(): + if max_cycle_nozzle is None or nozzle_points[nozzle] / head_num > nozzle_points[max_cycle_nozzle] / \ + nozzle_heads[max_cycle_nozzle]: + max_cycle_nozzle = nozzle + + assert max_cycle_nozzle is not None + nozzle_heads[max_cycle_nozzle] += 1 + + n_cycle = max(map(lambda x: math.ceil(nozzle_points[x[0]] / x[1]), nozzle_heads.items())) + + # calculate the number of simultaneous pickup + head_index, nozzle_cycle = 0, [[] for _ in range(max_head_index)] + for nozzle, heads in nozzle_heads.items(): + head_index_cpy, points = head_index, nozzle_points[nozzle] + for _ in range(heads): + nozzle_cycle[head_index].append([nozzle, points // heads]) + head_index += 1 + + points %= heads + while points: + nozzle_cycle[head_index_cpy][1] += 1 + points -= 1 + head_index_cpy += 1 + + # nozzle_cycle_index = [0 for _ in range(max_head_index)] + return n_cycle, n_nz_change, n_gang_pick def assemblyline_optimizer_heuristic(pcb_data, component_data): - assignment_result = [] + # the number of placement points, the number of available feeders, and nozzle type of component respectively + component_number = len(component_data) + component_points = [0 for _ in range(component_number)] + component_feeders = [0 for _ in range(component_number)] + component_nozzle = [0 for _ in range(component_number)] + component_part = [0 for _ in range(component_number)] - # for machine_index in range(max_machine_index): - # assembly_time_estimator(pcb_data, component_data, assignment_result[machine_index]) + nozzle_points = defaultdict(int) # the number of placements of nozzle + + for _, data in pcb_data.iterrows(): + part_index = component_data[component_data['part'] == data['part']].index.tolist()[0] + nozzle = component_data.loc[part_index]['nz'] + + component_points[part_index] += 1 + component_feeders[part_index] = component_data.loc[part_index]['feeder-limit'] + # component_feeders[part_index] = math.ceil(component_data.loc[part_index]['feeder-limit'] / max_feeder_limit) + component_nozzle[part_index] = nozzle + component_part[part_index] = data['part'] + + nozzle_points[nozzle] += 1 + + # first step: generate the initial solution with equalized workload + assignment_result = [[0 for _ in range(len(component_points))] for _ in range(max_machine_index)] + assignment_points = [0 for _ in range(max_machine_index)] + + # for part, points in enumerate(component_points): + # if component_nozzle[part] == 'CN065': + # assignment_result[1][part] += points + # assignment_points[1] += points + # component_points[part] = 0 + # elif component_nozzle[part] == 'CN220': + # assignment_result[2][part] += points + # assignment_points[2] += points + # component_points[part] = 0 + + weighted_points = list( + map(lambda x: x[1] + 1e-5 * nozzle_points[component_nozzle[x[0]]], enumerate(component_points))) + + for part_index in np.argsort(weighted_points): + if (total_points := component_points[part_index]) == 0: # total placements for each component type + continue + machine_set = [] + + # define the machine that assigning placement points (considering the feeder limitation) + for machine_index in np.argsort(assignment_points): + if len(machine_set) >= component_points[part_index] or len(machine_set) >= component_feeders[part_index]: + break + machine_set.append(machine_index) + + # Allocation of mounting points to available machines according to the principle of equality + while total_points: + assign_machine = list(filter(lambda x: assignment_points[x] == min(assignment_points), machine_set)) + + if len(assign_machine) == len(machine_set): + # averagely assign point to all available machines + points = total_points // len(assign_machine) + for machine_index in machine_set: + assignment_points[machine_index] += points + assignment_result[machine_index][part_index] += points + + total_points -= points * len(assign_machine) + for machine_index in machine_set: + if total_points == 0: + break + assignment_points[machine_index] += 1 + assignment_result[machine_index][part_index] += 1 + total_points -= 1 + else: + # assigning placements to make up for the gap between the least and the second least + second_least_machine, second_least_machine_points = -1, max(assignment_points) + 1 + for idx in machine_set: + if assignment_points[idx] < second_least_machine_points and assignment_points[idx] != min( + assignment_points): + second_least_machine_points = assignment_points[idx] + second_least_machine = idx + + assert second_least_machine != -1 + + if len(assign_machine) * (second_least_machine_points - min(assignment_points)) < total_points: + min_points = min(assignment_points) + total_points -= len(assign_machine) * (second_least_machine_points - min_points) + for machine_index in assign_machine: + assignment_points[machine_index] += (second_least_machine_points - min_points) + assignment_result[machine_index][part_index] += ( + second_least_machine_points - min_points) + else: + points = total_points // len(assign_machine) + for machine_index in assign_machine: + assignment_points[machine_index] += points + assignment_result[machine_index][part_index] += points + + total_points -= points * len(assign_machine) + for machine_index in assign_machine: + if total_points == 0: + break + assignment_points[machine_index] += 1 + assignment_result[machine_index][part_index] += 1 + total_points -= 1 + + # todo: implementation + + # second step: estimate the assembly time for each machine + # third step: adjust the assignment results to reduce maximal assembly time among all machines return assignment_result diff --git a/optimizer_spidermonkey.py b/optimizer_spidermonkey.py new file mode 100644 index 0000000..eb3410d --- /dev/null +++ b/optimizer_spidermonkey.py @@ -0,0 +1,11 @@ +# implementation of +# <> +def assemblyline_optimizer_spidermonkey(pcb_data, component_data): + # number of swarms: 10 + # maximum number of groups: 5 + # number of loops: 100 + # food source population: 50 + # mutation rate: 0.1 + # crossover rate: 0.9 + # computation time(s): 200 + pass diff --git a/result_analysis.py b/result_analysis.py index d7d9866..5793d68 100644 --- a/result_analysis.py +++ b/result_analysis.py @@ -362,14 +362,24 @@ def optimization_assign_result(component_data, pcb_data, component_result, cycle nozzle_assign = pd.DataFrame(columns=columns) for cycle, components in enumerate(component_result): - nozzle_assign.loc[cycle, 'cycle'] = cycle_result[cycle] + nozzle_assign_row = len(nozzle_assign) + nozzle_assign.loc[nozzle_assign_row, 'cycle'] = cycle_result[cycle] + for head in range(max_head_index): index = component_result[cycle][head] if index == -1: - nozzle_assign.loc[cycle, 'H{}'.format(head + 1)] = '' + nozzle_assign.loc[nozzle_assign_row, 'H{}'.format(head + 1)] = '' else: nozzle = component_data.loc[index]['nz'] - nozzle_assign.loc[cycle, 'H{}'.format(head + 1)] = nozzle + nozzle_assign.loc[nozzle_assign_row, 'H{}'.format(head + 1)] = nozzle + + for head in range(max_head_index): + if nozzle_assign_row == 0 or nozzle_assign.loc[nozzle_assign_row - 1, 'H{}'.format(head + 1)] != \ + nozzle_assign.loc[nozzle_assign_row, 'H{}'.format(head + 1)]: + break + else: + nozzle_assign.loc[nozzle_assign_row - 1, 'cycle'] += nozzle_assign.loc[nozzle_assign_row, 'cycle'] + nozzle_assign.drop([len(nozzle_assign) - 1], inplace=True) print(nozzle_assign) print('') @@ -449,17 +459,13 @@ def placement_time_estimate(component_data, pcb_data, component_result, cycle_re warnings.warn(info, UserWarning) return 0. - t_pick, t_place = .078, .051 # 贴装/拾取用时 - t_nozzle_put, t_nozzle_pick = 0.9, 0.75 # 装卸吸嘴用时 - t_fix_camera_check = 0.12 # 固定相机检测时间 - - total_moving_time = .0 # 总移动用时 - total_operation_time = .0 # 操作用时 - total_nozzle_change_counter = 0 # 总吸嘴更换次数 - total_pick_counter = 0 # 总拾取次数 - total_mount_distance, total_pick_distance = .0, .0 # 贴装距离、拾取距离 - total_distance = 0 # 总移动距离 - cur_pos, next_pos = anc_marker_pos, [0, 0] # 贴装头当前位置 + total_pickup_time, total_round_time, total_place_time = .0, .0, 0 # 拾取用时、往返用时、贴装用时 + total_operation_time = .0 # 操作用时 + total_nozzle_change_counter = 0 # 总吸嘴更换次数 + total_pick_counter = 0 # 总拾取次数 + total_mount_distance, total_pick_distance = .0, .0 # 贴装距离、拾取距离 + total_distance = 0 # 总移动距离 + cur_pos, next_pos = anc_marker_pos, [0, 0] # 贴装头当前位置 # 初始化首个周期的吸嘴装配信息 nozzle_assigned = ['Empty' for _ in range(max_head_index)] @@ -492,8 +498,10 @@ def placement_time_estimate(component_data, pcb_data, component_result, cycle_re # ANC处进行吸嘴更换 if nozzle_pick_counter + nozzle_put_counter > 0: next_pos = anc_marker_pos - total_moving_time += max(axis_moving_time(cur_pos[0] - next_pos[0], 0), - axis_moving_time(cur_pos[1] - next_pos[1], 1)) + move_time = max(axis_moving_time(cur_pos[0] - next_pos[0], 0), + axis_moving_time(cur_pos[1] - next_pos[1], 1)) + total_round_time += move_time + total_distance += max(abs(cur_pos[0] - next_pos[0]), abs(cur_pos[1] - next_pos[1])) cur_pos = next_pos @@ -501,15 +509,21 @@ def placement_time_estimate(component_data, pcb_data, component_result, cycle_re pick_slot = sorted(pick_slot, reverse=True) # 拾取路径(自右向左) - for slot in pick_slot: + for idx, slot in enumerate(pick_slot): if slot < max_slot_index // 2: next_pos = [slotf1_pos[0] + slot_interval * (slot - 1), slotf1_pos[1]] else: next_pos = [slotr1_pos[0] - slot_interval * (max_slot_index - slot - 1), slotr1_pos[1]] total_operation_time += t_pick total_pick_counter += 1 - total_moving_time += max(axis_moving_time(cur_pos[0] - next_pos[0], 0), - axis_moving_time(cur_pos[1] - next_pos[1], 1)) + + move_time = max(axis_moving_time(cur_pos[0] - next_pos[0], 0), + axis_moving_time(cur_pos[1] - next_pos[1], 1)) + if idx == 0: + total_round_time += move_time + else: + total_pickup_time += move_time + total_distance += max(abs(cur_pos[0] - next_pos[0]), abs(cur_pos[1] - next_pos[1])) if slot != pick_slot[0]: total_pick_distance += max(abs(cur_pos[0] - next_pos[0]), abs(cur_pos[1] - next_pos[1])) @@ -522,8 +536,10 @@ def placement_time_estimate(component_data, pcb_data, component_result, cycle_re camera = component_data.loc[component_result[cycle_set][head]]['camera'] if camera == '固定相机': next_pos = [fix_camera_pos[0] - head * head_interval, fix_camera_pos[1]] - total_moving_time += max(axis_moving_time(cur_pos[0] - next_pos[0], 0), - axis_moving_time(cur_pos[1] - next_pos[1], 1)) + move_time = max(axis_moving_time(cur_pos[0] - next_pos[0], 0), + axis_moving_time(cur_pos[1] - next_pos[1], 1)) + total_round_time += move_time + total_distance += max(abs(cur_pos[0] - next_pos[0]), abs(cur_pos[1] - next_pos[1])) total_operation_time += t_fix_camera_check cur_pos = next_pos @@ -545,22 +561,26 @@ def placement_time_estimate(component_data, pcb_data, component_result, cycle_re # 考虑R轴预旋转，补偿同轴角度转动带来的额外贴装用时 total_operation_time += head_rotary_time(mount_angle[0]) # 补偿角度转动带来的额外贴装用时 total_operation_time += t_nozzle_put * nozzle_put_counter + t_nozzle_pick * nozzle_pick_counter - for pos in mount_pos: + for idx, pos in enumerate(mount_pos): total_operation_time += t_place - total_moving_time += max(axis_moving_time(cur_pos[0] - pos[0], 0), - axis_moving_time(cur_pos[1] - pos[1], 1)) + move_time = max(axis_moving_time(cur_pos[0] - pos[0], 0), axis_moving_time(cur_pos[1] - pos[1], 1)) + if idx == 0: + total_round_time += move_time + else: + total_place_time += move_time + total_distance += max(abs(cur_pos[0] - pos[0]), abs(cur_pos[1] - pos[1])) cur_pos = pos total_nozzle_change_counter += nozzle_put_counter + nozzle_pick_counter - total_time = total_moving_time + total_operation_time + total_time = total_pickup_time + total_round_time + total_place_time + total_operation_time minutes, seconds = int(total_time // 60), int(total_time) % 60 millisecond = int((total_time - minutes * 60 - seconds) * 60) if hinter: optimization_assign_result(component_data, pcb_data, component_result, cycle_result, feeder_slot_result, - nozzle_hinter=True, component_hinter=True, feeder_hinter=True) + nozzle_hinter=False, component_hinter=False, feeder_hinter=False) print('-Cycle counter: {}'.format(sum(cycle_result))) print('-Nozzle change counter: {}'.format(total_nozzle_change_counter // 2)) @@ -570,7 +590,9 @@ def placement_time_estimate(component_data, pcb_data, component_result, cycle_re print('-Expected picking tour length: {} mm'.format(total_pick_distance)) print('-Expected total tour length: {} mm'.format(total_distance)) - print('-Expected total moving time: {} s'.format(total_moving_time)) + print('-Expected total moving time: {} s with pick: {}, round: {}, place = {}'.format( + total_pickup_time + total_round_time + total_place_time, total_pickup_time, total_round_time, + total_place_time)) print('-Expected total operation time: {} s'.format(total_operation_time)) if minutes > 0: