def get_trajectory_regularised(params, ampl_mdl_path, hide_solver_output=True): ampl = AMPL() ampl.read(ampl_mdl_path) for lbl, val in params.items(): _ampl_set_param(ampl, lbl, val) _ampl_set_param(ampl, 'reg', 0) # no regularisation _ampl_solve(ampl, hide_solver_output) optimal_sol_found = _ampl_optimal_sol_found(ampl) traj = None objective = None optimal_sol_found_reg = False if optimal_sol_found: _ampl_set_param(ampl, 'reg', 1) # regularisation _ampl_solve(ampl, hide_solver_output) optimal_sol_found_reg = _ampl_optimal_sol_found(ampl) if optimal_sol_found_reg: traj = _extract_trajectory_from_solver(ampl) objective = ampl.getObjective('myobjective').value() ampl.close() return optimal_sol_found_reg, traj, objective
def compute_defense(att_stg, prod_dist, num_of_hp=args.fix_honeypots, rationality=args.fix_rationality): # production ports and attacker"s strategy df = DataFrame('P') ports = getRelPorts(att_stg, prod_dist, num=25) df.setColumn('P', list(ports)) #ports = getAllPorts(att_stg, prod_dist) #print(('Considered ports are: ', ports)) att = [att_stg.get(x, 0) for x in ports] prod = [prod_dist.get(x, 0) for x in ports] #print(('Attack ports: ', att, len(att))) #print(('Dist ports: ', prod, len(prod))) df.addColumn('s', prod) df.addColumn('p', att) ampl = AMPL(Environment(args.ampl)) ampl.setOption('solver', args.solver) # ampl.setOption('verbosity', 'terse') # Read the model file ampl.read(args.model) # Assign data to s ampl.setData(df, 'P') ampl.eval('let L := {}; let rat := {};'.format(num_of_hp, rationality)) #print(df) # Solve the model with suppress_stdout(): ampl.solve() reward = ampl.getObjective("reward").value() hp_stg = ampl.getData("{j in P} h[j]") output = dict() stg_json = list() for k, v in hp_stg.toDict().items(): stg_json.append({"port": int(k), "prob": v}) output.update({"stg": stg_json}) output.update({"reward": reward}) output.update({"rationality": rationality}) output.update({"num_of_hp": num_of_hp}) output.update({"used_hps": ampl.getData("tot").toDict().popitem()[1]}) ampl.close() return output
def testEnvironment(self): from amplpy import Environment, AMPL env1 = Environment() env2 = Environment(os.curdir) self.assertEqual(env2.getBinDir(), os.curdir) env1.setBinDir(env2.getBinDir()) self.assertEqual(env1.getBinDir(), env1.getBinDir()) self.assertEqual(len(dict(env1)), len(list(env1))) self.assertEqual(list(sorted(dict(env1).items())), list(sorted(env1))) env1['MyEnvVar'] = 'TEST' self.assertEqual(env1['MyEnvVar'], 'TEST') self.assertEqual(env2['MyEnvVar'], None) d = dict(env1) self.assertEqual(d['MyEnvVar'], 'TEST') ampl = AMPL(Environment()) ampl.close()
def test_environment(self): from amplpy import Environment, AMPL env1 = Environment() env2 = Environment(os.curdir) self.assertEqual(env2.get_bin_dir(), os.curdir) env1.set_bin_dir(env2.get_bin_dir()) self.assertEqual(env1.get_bin_dir(), env1.get_bin_dir()) self.assertEqual(len(dict(env1)), len(list(env1))) self.assertEqual(list(sorted(dict(env1).items())), list(sorted(env1))) env1["MyEnvVar"] = "TEST" self.assertEqual(env1["MyEnvVar"], "TEST") self.assertEqual(env2["MyEnvVar"], None) d = dict(env1) self.assertEqual(d["MyEnvVar"], "TEST") ampl = AMPL(Environment()) ampl.close()
def get_trajectory(params, ampl_mdl_path, hide_solver_output=True): ampl = AMPL( ) # ampl installation directory should be in system search path # .mod file ampl.read(ampl_mdl_path) # set parameter values for lbl, val in params.items(): _ampl_set_param(ampl, lbl, val) _ampl_solve(ampl, hide_solver_output) optimal_sol_found = _ampl_optimal_sol_found(ampl) traj = None objective = None if optimal_sol_found: traj = _extract_trajectory_from_solver(ampl) objective = ampl.getObjective('myobjective').value() ampl.close() return optimal_sol_found, traj, objective
def prodalloc(RID, SID, shared_ns=None, f_out=None, f_log=None): from amplpy import AMPL, DataFrame if shared_ns == None: (df_demand, wup_12mavg, ppp_sum12, df_scenario, sw_avail, df_penfunc, df_relcost) = pull_data(RID, SID) # ======================================= # instantiate AMPL class and set AMPL options ampl = AMPL() # set options ampl.setOption('presolve', False) ampl.setOption('solver', 'gurobi_ampl') # ampl.setOption('solver', 'cbc') ampl.setOption('gurobi_options', 'iisfind=1 iismethod=1 lpmethod=4 mipgap=1e-6 warmstart=1') ampl.setOption('reset_initial_guesses', True) ampl.setOption('solver_msg', True) # real model from model file d_cur = os.getcwd() f_model = os.path.join(d_cur, 'model.amp') ampl.read(f_model) if shared_ns != None: df_demand = shared_ns.df_demand.query( f'RealizationID == {RID}').loc[:, ['wpda', 'dates', 'Demand']] dates = df_demand.loc[:, ['dates']].values df_demand.loc[:, 'dates'] = [ pd.to_datetime(d).strftime('%Y-%b') for d in dates ] df_demand.set_index(keys=['wpda', 'dates'], inplace=True) wpda = sorted(list(set([w for (w, m) in df_demand.index]))) monyr = df_demand.loc[('COT', ), ].index.values nyears = int(len(monyr) / 12.0) # lambda for determine number of days in a month dates = dates[0:(12 * nyears)] f_ndays_mo = lambda aday: (aday + dt.timedelta(days=32)).replace(day=1 ) - aday ndays_mo = map(f_ndays_mo, [pd.to_datetime(d[0]) for d in dates]) ndays_mo = [i.days for i in ndays_mo] # add data to sets -- Demand ampl.getParameter('nyears').value = nyears ampl.getSet('monyr').setValues(monyr) ampl.getSet('wpda').setValues(wpda) ampl.getParameter('demand').setValues(DataFrame.fromPandas(df_demand)) ampl.getParameter('ndays_mo').setValues(ndays_mo) # index to year number yearno = [(i // 12) + 1 for i in range(len(dates))] ampl.getParameter('yearno').setValues(np.asarray(yearno)) monthno = [pd.to_datetime(d[0]).month for d in dates] ampl.getParameter('monthno').setValues(np.asarray(monthno)) # --------------------------------------- # WUP and preferred ranges if shared_ns != None: wup_12mavg = shared_ns.wup_12mavg ampl.getParameter('wup_12mavg').setValues( DataFrame.fromPandas(wup_12mavg.loc[:, ['wup_12mavg']])) ampl.getParameter('prod_range_lo').setValues( DataFrame.fromPandas(wup_12mavg.loc[:, ['prod_range_lo']])) ampl.getParameter('prod_range_hi').setValues( DataFrame.fromPandas(wup_12mavg.loc[:, ['prod_range_hi']])) # add ppp_sum12 if shared_ns != None: ppp_sum12 = shared_ns.ppp_sum12 ppp_sum12.loc[:, 'monyr'] = [i for i in range(1, 12)] * 3 ppp_sum12.set_index(keys=['WF', 'monyr'], inplace=True) ampl.getParameter('ppp_sum12').setValues(DataFrame.fromPandas(ppp_sum12)) # Relative cost of water per a million gallon if shared_ns != None: df_relcost = shared_ns.df_relcost ampl.getParameter('relcost').setValues(DataFrame.fromPandas(df_relcost)) # --------------------------------------- # Scenario's data if shared_ns != None: df_scenario = shared_ns.df_scenario.query( f'ScenarioID=={SID}').loc[:, ['ParameterName', 'MonthNo', 'Value']] AVAIL_PCTILE = df_scenario.query(f"ParameterName == 'AVAIL_PCTILE'") AVAIL_PCTILE = AVAIL_PCTILE.loc[AVAIL_PCTILE.index, 'Value'].values[0] RES_INIT = df_scenario.query(f"ParameterName == 'RES_INIT'") RES_INIT = RES_INIT.loc[RES_INIT.index, 'Value'].values[0] # Surface Water Availability Data by month repeated for nyears ampl.getParameter('avail_pctile').value = AVAIL_PCTILE if shared_ns != None: sw_avail = shared_ns.sw_avail.query( f'Percentile == {AVAIL_PCTILE}' ).loc[:, ['source', 'monthno', 'value']] # sw_avail = temp.copy() # if nyears > 1: # for i in range(1, nyears): # sw_avail = sw_avail.append(temp) # srcs = sw_avail.loc[:, 'source'].unique() # for j in srcs: # sw_avail.loc[sw_avail['source']==j,'monthno'] = [i+1 for i in range(len(monyr))] # sw_avail.set_index(keys=['source', 'monthno'], inplace=True) # ampl.getParameter('ngw_avail').setValues(DataFrame.fromPandas(sw_avail)) sw_avail.set_index(keys=['source', 'monthno'], inplace=True) ampl.getParameter('ngw_avail').setValues(DataFrame.fromPandas(sw_avail)) # --------------------------------------- # Penalty functions for under utilization if shared_ns != None: df_penfunc = shared_ns.df_penfunc ampl.getParameter('penfunc_x').setValues( DataFrame.fromPandas(df_penfunc.loc[:, ['under_limit']])) ampl.getParameter('penfunc_r').setValues( DataFrame.fromPandas(df_penfunc.loc[:, ['penalty_rate']])) ''' # ======================================= # Read fixed allocation from spreadsheet # f_excel = os.path.join( # d_cur, 'WY 2019 monthly delivery and supply for budget InitialDraft.xlsx') sheet_names = ['WY 2019','WY 2020','WY 2021','WY 2022','WY 2023','WY 2024'] # ch_poc: Central Hills delivery (row 16) # reg_lithia: Regional to Lithia (row 20) # reg_cot: Regional to City of Tampa (row 26) # reg_thic: THIC intertie purchase (row 37) # crw_prod: Carrollwood WF production (row 40) # eag_prod: Production for Eagle Well (row 41) # row index is zero based, minus one header row = -2 row_offset = -2 ch_poc, reg_lithia, reg_cot, reg_thic, crw_prod, eag_prod = [], [], [], [], [], [] # These DV is fixed or receives values from other optimizer bud_fix, ds_fix, swtp_fix=[], [], [] for i in range(nyears): df_excel = pd.read_excel(f_excel, sheet_names[i], usecols='C:N', nrows=41) ch_poc .extend(list(df_excel.loc[16 + row_offset, :].values)) reg_lithia.extend(list(df_excel.loc[20 + row_offset, :].values)) reg_cot .extend(list(df_excel.loc[26 + row_offset, :].values)) reg_thic .extend(list(df_excel.loc[37 + row_offset, :].values)) crw_prod .extend(list(df_excel.loc[40 + row_offset, :].values)) eag_prod .extend(list(df_excel.loc[41 + row_offset, :].values)) bud_fix .extend(list(df_excel.loc[22 + row_offset, :].values)) ds_fix .extend(list(df_excel.loc[36 + row_offset, :].values)) swtp_fix.extend(list(df_excel.loc[38 + row_offset, :].values)) ''' ch_poc = df_scenario[df_scenario.ParameterName == 'ch_poc'].Value reg_lithia = df_scenario[df_scenario.ParameterName == 'reg_lithia'].Value reg_cot = df_scenario[df_scenario.ParameterName == 'reg_cot'].Value reg_thic = df_scenario[df_scenario.ParameterName == 'reg_thic'].Value crw_prod = df_scenario[df_scenario.ParameterName == 'crw_prod'].Value eag_prod = df_scenario[df_scenario.ParameterName == 'eag_prod'].Value ampl.getParameter('ch_poc').setValues(np.asarray(ch_poc, dtype=np.float32)) ampl.getParameter('reg_lithia').setValues( np.asarray(reg_lithia, dtype=np.float32)) ampl.getParameter('reg_cot').setValues( np.asarray(reg_cot, dtype=np.float32)) ampl.getParameter('reg_thic').setValues( np.asarray(reg_thic, dtype=np.float32)) ampl.getParameter('crw_prod').setValues( np.asarray(crw_prod, dtype=np.float32)) ampl.getParameter('eag_prod').setValues( np.asarray(eag_prod, dtype=np.float32)) # overloaded function 'VariableInstance_fix' need float64 bud_fix = np.asarray( df_scenario[df_scenario.ParameterName == 'bud_fix'].Value, dtype=np.float64) ds_fix = np.asarray( df_scenario[df_scenario.ParameterName == 'ds_fix'].Value, dtype=np.float64) swtp_fix = np.asarray( df_scenario[df_scenario.ParameterName == 'swtp_fix'].Value, dtype=np.float64) ampl.getParameter('bud_fix').setValues( np.asarray(bud_fix, dtype=np.float32)) ampl.getParameter('ds_fix').setValues(np.asarray(ds_fix, dtype=np.float32)) ampl.getParameter('swtp_fix').setValues( np.asarray(swtp_fix, dtype=np.float32)) # --------------------------------------- # initialize/fix variable values ampl.getParameter('res_init').value = RES_INIT res_vol = ampl.getVariable('res_vol') res_vol[0].fix(RES_INIT) gw_prod = ampl.getVariable('gw_prod') bud_prod = [ gw_prod[j, i] for ((j, i), k) in gw_prod.instances() if j == 'BUD' ] for i in range(len(bud_prod)): bud_prod[i].fix(bud_fix[i]) ds_prod = ampl.getVariable('ds_prod') for i in range(ds_prod.numInstances()): ds_prod[i + 1].fix(ds_fix[i]) swtp_prod = ampl.getVariable('swtp_prod') for i in range(swtp_prod.numInstances()): swtp_prod[i + 1].fix(swtp_fix[i]) # --------------------------------------- # dump data with open('dump.dat', 'w') as f: with stdout_redirected(f): ampl.display('wpda,monyr') ampl.display('demand') ampl.display('nyears') ampl.display('ndays_mo,yearno,monthno') # ampl.display('years') # ampl.display('dem_total') ampl.display( 'ch_poc,reg_lithia,reg_cot,reg_thic,crw_prod,eag_prod,bud_fix,ds_fix' ) ampl.display('wup_12mavg') ampl.display('ppp_sum12') ampl.display('ngw_avail') ampl.display('prod_range_lo,prod_range_hi') ampl.display('relcost') ampl.display('penfunc_x,penfunc_r') # ======================================= # silence solver with open('nul', 'w') as f: with stdout_redirected(f): ampl.solve() if f_out != None: with open(f_out, 'w') as f: print(r'# *** SOURCE ALLOCATION MODEL ****', file=f) print(r'# Monthly Delivery and Supply for Budgeting', file=f) print('\n# Objective: {}'.format( ampl.getObjective('mip_obj').value()), file=f) if (f_log != None) & (ampl.getObjective('mip_obj').result() == 'solved'): with open(f_log, "w") as f: print('\n\nDump Variable and Constraint Values', file=f) with stdout_redirected(f): write_log(ampl) if ampl.getObjective('mip_obj').result() == 'infeasible': if f_log != None: with open(f_log, "w") as f: with stdout_redirected(f): write_iis(ampl) else: write_iis(ampl) # ======================================= # print output # groundwater production temp = ampl.getVariable('gw_prod').getValues().toPandas().join( ampl.getVariable('gw_under').getValues().toPandas()).join( ampl.getVariable('gw_over').getValues().toPandas()) temp.columns = [i.replace('.val', '') for i in temp.columns] # pivoting df by source cwup_prod = temp.loc[[i for i in temp.index if i[0] == 'CWUP'], :].assign( index=monyr).set_index('index').rename(columns={ 'gw_prod': 'cwup_prod', 'gw_under': 'cwup_under', 'gw_over': 'cwup_over' }) bud_prod = temp.loc[[i for i in temp.index if i[0] == 'BUD'], :].assign( index=monyr).set_index('index').rename(columns={ 'gw_prod': 'bud_prod', 'gw_under': 'bud_under', 'gw_over': 'bud_over' }) sch_prod = temp.loc[[i for i in temp.index if i[0] == 'SCH'], :].assign( index=monyr).set_index('index').rename(columns={ 'gw_prod': 'sch_prod', 'gw_under': 'sch_under', 'gw_over': 'sch_over' }) temp = cwup_prod.join(sch_prod.join(bud_prod)) gw_results = temp temp_avg = temp.groupby(by=yearno).mean().reset_index() temp_avg = temp_avg.loc[:, [i for i in temp_avg.columns[1:temp_avg.shape[1]]]] if f_out != None: with open(f_out, 'a') as f: # print heading print('\n\n# Monthly Groudwater Production', file=f) for l in range(len(temp)): if (l % 12) == 0: print(('\n%10s' % 'Yr-Month') + ('%11s' * len(temp.columns) % tuple(temp.columns)), file=f) print(('%10s' % monyr[l]) + ('%11.3f' * len(temp.columns) % tuple(temp.iloc[l, :].values)), file=f) if (l + 1) % 12 == 0: print(('%10s' % 'Average') + ('%11.3f' * len(temp_avg.columns) % tuple(temp_avg.iloc[l // 12, :].values)), file=f) print( ('\n%10s' % 'Total Avg') + ('%11.3f' * len(temp_avg.columns) % tuple(temp_avg.mean().values)), file=f) # --------------------------------------- # SWTP Production to_swtp = ampl.getVariable('to_swtp').getValues().toPandas() to_res = ampl.getVariable('to_res').getValues().toPandas() idx = to_swtp.index temp = ampl.getVariable('swtp_prod').getValues().toPandas() temp = temp.assign(tbc_swtp=to_swtp.loc[[i for i in idx if i[0] == 'TBC']].values) temp = temp.assign( alf_swtp=to_swtp.loc[[i for i in idx if i[0] == 'Alafia']].values) temp = temp.join(ampl.getVariable('res_eff').getValues().toPandas()) temp = temp.assign(tbc_res=to_res.loc[[i for i in idx if i[0] == 'TBC']].values) temp = temp.assign(alf_res=to_res.loc[[i for i in idx if i[0] == 'Alafia']].values) temp = temp.join(ampl.getVariable('res_inf').getValues().toPandas()).join( ampl.getVariable('res_vol').getValues().toPandas()) # Add availability columns temp = temp.assign(tbc_avail=sw_avail.loc[[('TBC', i) for i in monthno], ['value']].values) temp = temp.assign(alf_avail=sw_avail.loc[[('Alafia', i) for i in monthno], ['value']].values) # Add SW withdraws df1 = ampl.getVariable('sw_withdraw').getValues().toPandas() idx = temp.index temp = temp.assign(tbc_wthdr=df1.loc[[('TBC', i) for i in idx], :].values) temp = temp.assign(alf_wthdr=df1.loc[[('Alafia', i) for i in idx], :].values) temp.columns = [i.replace('.val', '') for i in temp.columns] sw_results = temp # Compute annual average temp_avg = temp.groupby(by=yearno).mean().reset_index() temp_avg = temp_avg.loc[:, [i for i in temp_avg.columns[1:temp_avg.shape[1]]]] if f_out != None: with open(f_out, 'a') as f: # print heading print('\n\n# Monthly Surface Water Production', file=f) for l in range(len(temp)): if (l % 12) == 0: print(('\n%10s' % 'Yr-Month') + ('%10s' * len(temp.columns) % tuple(temp.columns)), file=f) print(('%10s' % monyr[l]) + ('%10.3f' * len(temp.columns) % tuple(temp.loc[float(l + 1), :])), file=f) if ((l + 1) % 12) == 0: print(('%10s' % 'Average') + ('%10.3f' * len(temp_avg.columns) % tuple(temp_avg.loc[l // 12, :])), file=f) print( ('\n%10s' % 'Total Avg') + ('%10.3f' * len(temp_avg.columns) % tuple(temp_avg.mean().values)), file=f) # --------------------------------------- # print multi objective values temp = ampl.getVariable('prodcost_avg').getValues().toPandas() idx = [i for i in temp.index] temp = temp.assign( prod_avg=temp.loc[:, 'prodcost_avg.val'] * 1e-3 / np.asarray([df_relcost.loc[i[0], 'relcost'] for i in idx])) temp = temp.join( ampl.getVariable('uu_penalty').getValues().toPandas()).join( ampl.getVariable('uu_avg').getValues().toPandas()) temp.columns = [i.replace('.val', '') for i in temp.columns] temp_avg = temp.groupby([i[0] for i in temp.index]).mean().reset_index() if f_out != None: with open(f_out, 'a') as f: print( '\n\n# Annual Production and Under Utilization (Opportunity) Costs', file=f) for l in range(len(temp)): if (l % nyears) == 0: print(('\n%10s%10s' % ('YearNo', 'Source')) + ('%15s' * len(temp.columns) % tuple(temp.columns)), file=f) print(('%10d%10s' % (idx[l][1], idx[l][0])) + ('%15.3f' * len(temp.columns) % tuple(temp.loc[[idx[l]], :].values[0])), file=f) if ((l + 1) % nyears) == 0: print(('%10s' % 'Average') + (('%10s' + '%15.3f' * len(temp.columns)) % tuple(temp_avg.iloc[l // nyears, :])), file=f) ampl.close() # prepare data for ploting if f_out != None: df_plotdata = df_demand.groupby(level=1).sum().join(df_demand.loc[( 'COT', ), ['Demand']].rename(columns={'Demand': 'COT'})).assign( TBW_Demand=lambda x: x.Demand - x.COT).loc[:, ['TBW_Demand']].join( gw_results.join(sw_results.set_index(gw_results.index))) monyr = [pd.Timestamp(i + '-01') for i in df_plotdata.index] df_plotdata = df_plotdata.assign( Dates=monyr).set_index('Dates').sort_index() df_plotdata = df_plotdata.assign(ndays_mo=ndays_mo) plot_results(SID, AVAIL_PCTILE, df_plotdata, f_out)
def fix_create_run(self, nest_tuple, cost_list): effective_lv = list(self.level_list) fix_dict = { 'L0Tb': 1, 'L0Tx': 1, 'L0Ty': self.numAB[0], 'L0Tf': self.numAB[1], 'L0Tc': 1, 'L0Tw': 1, 'L0Th': 1, 'L1Tw': self.pbsize_dict['w'], 'L1Th': self.pbsize_dict['h'] } cost_score = [] bottleneck_list = [] all_tiles = {} while len(effective_lv) > 0: best_target_cost = [ -1, math.inf, {} ] # best lv, best lv cost, tile names fixed by best lv for target_lv in effective_lv: try: ampl = AMPL() ampl.setOption('solver', 'ipopt') modfile_name, cost_expr_list = self.create_modfile( nest_tuple, cost_list, target_lv, effective_lv) ampl.read(modfile_name) fixed_vars = [] for fixtile_name in fix_dict.keys(): print(fixtile_name) fixvar = ampl.getVariable(name=fixtile_name) fixvar.fix(value=fix_dict.get(fixtile_name)) fixed_vars.append(fixvar) ampl.solve() maxcost = ampl.getObjective('maxcost') tofix_tiles = {} target_expr = cost_expr_list[self.level_list.index( target_lv)] for tofix_t in target_expr.free_symbols: fixvar = ampl.getVariable(str(tofix_t)) tofix_tiles[str(tofix_t)] = math.floor(fixvar.value()) if maxcost.value( ) < best_target_cost[1] and maxcost.exitcode( ) == 0 and 'Optimal Solution Found' in maxcost.message(): best_target_cost[0] = target_lv best_target_cost[1] = maxcost.value() best_target_cost[2] = dict(tofix_tiles) if len(effective_lv) == 1: for lv in list(self.level_list) + list( self.parallel_list): for idx in self.idx_list: Tx_name = str( self.pool.get_sym(idx=idx, tlv=lv)) Tx_var = ampl.getVariable(name=Tx_name) Tx_value = math.floor(Tx_var.value()) all_tiles[Tx_name] = Tx_value ampl.close() except Exception as e: print(e) raise if (best_target_cost[0] < 0): return 'invalid' delete_lv = best_target_cost[0] bottle_cost = best_target_cost[1] print('lv', delete_lv, 'is bottleneck ', bottle_cost) tofix_tile_dict = best_target_cost[2] cost_score.append(best_target_cost[1]) bottleneck_list.append(best_target_cost[0]) popidx = effective_lv.index(delete_lv) effective_lv.pop(popidx) for tofix in tofix_tile_dict.keys(): if fix_dict.get(tofix) == None: fix_dict[tofix] = tofix_tile_dict.get(tofix) for fkey in fix_dict.keys(): pblv = 'L' + str(self.level_list[-1] + 1) if pblv in fkey: continue fv = fix_dict.get(fkey) av = all_tiles.get(fkey) if (fv != av): print('fkey fv av:', fkey, fv, av) assert (av == fv) return cost_score, bottleneck_list, all_tiles, nest_tuple