From bbcdee5b94a196ca3fd617039193029abc6d1c93 Mon Sep 17 00:00:00 2001 From: Robert Date: Wed, 20 Feb 2019 12:32:59 -0500 Subject: [PATCH] Changed names working test for backwards compatability --- algorithm/s_bfl.py | 99 +++++++++++++++++++++++++--------------------- myapp.py | 40 +++++++++---------- 2 files changed, 75 insertions(+), 64 deletions(-) diff --git a/algorithm/s_bfl.py b/algorithm/s_bfl.py index a0a3240..1ff47c2 100644 --- a/algorithm/s_bfl.py +++ b/algorithm/s_bfl.py @@ -29,37 +29,48 @@ def input(self, input_data, sysnum, t_lim = 10, jit=False, **kwargs): self.jit = jit self.sysnum = sysnum self.params = create_data(input_data, self.sysnum, **kwargs) - (*_, self.a, self.c_op, self.c_op_jit, self.c_pen, self.cfs, self.cs, self.cs_jit, - self.csk, self.d, self.hf, self.hs, self.U, self.UE, self.UE_jit) = self.params.values() + (*_, self.harvested, self.operating_cost, self.operating_cost_jit, self.c_pen, self.farm_ssl_trans_cost, self.ssl_refinery_trans_cost, self.ssl_refinery_jit_trans_cost, + self.fixed_cost_ssls, self.demand, self.farm_holding_cost, self.ssl_holding_cost, self.upperbound_inventory, self.upperbound_equip_proc_rate, self.upperbound_equip_proc_rate_jit) = self.params.values() def solve(self): - # variable names let's make it clear - T = list(range(1, len(self.d))) - F = list(range(len(self.cfs))) - S = list(range(len(self.csk))) - K = list(range(len(self.U))) - a = np.array(self.a) - M = a.sum(axis=0) - c_zfs = (np.array(self.cfs) + self.c_op).tolist() - c_z_jit = (np.array(self.cs_jit)[None] + np.array(self.cfs) + self.c_op_jit).tolist() + # T, F, S, K : Set of time periods, farms, potential SSL sites, and available types of SSLs, respectively + # t, f, s, k : element of T, F, S, K + T = list(range(1, len(self.demand))) + F = list(range(len(self.farm_ssl_trans_cost))) + S = list(range(len(self.fixed_cost_ssls))) + K = list(range(len(self.upperbound_inventory))) + + harvested = np.array(self.harvested) + M = harvested.sum(axis=0) + farm_ssl_cost_per_period = (np.array(self.farm_ssl_trans_cost) + self.operating_cost).tolist() + jit_trans_costs = (np.array(self.ssl_refinery_jit_trans_cost)[None] + np.array(self.farm_ssl_trans_cost) + self.operating_cost_jit).tolist() logger.info("Parameters created. Begin building model.") m = Model('ms1m_base') + # ++++++ Linear Programming Notation ++++++ # ====== Create vars and objectives ====== - w = m.addVars(S, K, obj=self.csk, vtype='B', name='w') + + # w[s][k] = 1 => is an ssl of type k is built at site s; otherwise 0 + w = m.addVars(S, K, obj=self.fixed_cost_ssls, vtype='B', name='w') + + # y[f][s] = 1 => if farm f supplies ssl s; 0 otherwise y = m.addVars(F, S, vtype='B', name='y') - zfs = m.addVars(T, F, S, obj=c_zfs * len(T), name='zfs') - zs = m.addVars(T, S, obj=self.cs * len(T), name='zs') - Is = m.addVars([0] + T, S, obj=self.hs, name='Is') - If = m.addVars([0] + T, F, obj=self.hf, name='If') + + shipped_farm_ssl = m.addVars(T, F, S, obj=farm_ssl_cost_per_period * len(T), name='shipped_farm_ssl') + shipped_ssl_refinery = m.addVars(T, S, obj=self.ssl_refinery_trans_cost * len(T), name='shipped_ssl_refinery') + + # Note: inventory levels taken at the end of period t + inventory_level_ssl = m.addVars([0] + T, S, obj=self.ssl_holding_cost, name='inventory_level_ssl') + inventory_level_farm = m.addVars([0] + T, F, obj=self.farm_holding_cost, name='inventory_level_farm') + if self.jit: - z_jit = m.addVars(T, F, S, obj=c_z_jit * len(T), name='z_jit') + z_jit = m.addVars(T, F, S, obj=jit_trans_costs * len(T), name='z_jit') penalty = m.addVars(T, obj=self.c_pen, name='penalty') - m.setAttr('UB', Is.select(0, '*'), [0] * len(S)) - m.setAttr('UB', If.select(0, '*'), [0] * len(F)) + m.setAttr('UB', inventory_level_ssl.select(0, '*'), [0] * len(S)) + m.setAttr('UB', inventory_level_farm.select(0, '*'), [0] * len(F)) m.ModelSense = GRB.MINIMIZE @@ -67,42 +78,42 @@ def solve(self): m.addConstrs((w.sum(s, '*') <= 1 for s in S), name='c1') m.addConstrs((y[f, s] <= w.sum(s, '*') for f in F for s in S), name='c2') m.addConstrs((y.sum(f, '*') == 1 for f in F), name='c3') - m.addConstrs((Is[t, s] == Is[t - 1, s] - zs[t, s] + zfs.sum(t, '*', s) + m.addConstrs((inventory_level_ssl[t, s] == inventory_level_ssl[t - 1, s] - shipped_ssl_refinery[t, s] + shipped_farm_ssl.sum(t, '*', s) for t in T for s in S), name='c4') - m.addConstrs((Is[t, s] <= quicksum([self.U[k] * w[s, k] for k in K]) for t in T + m.addConstrs((inventory_level_ssl[t, s] <= quicksum([self.upperbound_inventory[k] * w[s, k] for k in K]) for t in T for s in S), name='c7') - m.addConstrs((zfs.sum(t, '*', s) <= quicksum([self.UE[k] * w[s, k] for k in K]) + m.addConstrs((shipped_farm_ssl.sum(t, '*', s) <= quicksum([self.upperbound_equip_proc_rate[k] * w[s, k] for k in K]) for t in T for s in S), name='c9a') if not self.jit: - m.addConstrs((If[t, f] == If[t - 1, f] + a[t, f] - zfs.sum(t, f, '*') + m.addConstrs((inventory_level_farm[t, f] == inventory_level_farm[t - 1, f] + harvested[t, f] - shipped_farm_ssl.sum(t, f, '*') for t in T for f in F), name='c5') - m.addConstrs((zs.sum(t, '*') + penalty[t] == self.d[t] for t in T), + m.addConstrs((shipped_ssl_refinery.sum(t, '*') + penalty[t] == self.demand[t] for t in T), name='c6') m.addConstrs( - (zfs.sum('*', f, s) <= M[f] * y[f, s] for f in F for s in S), + (shipped_farm_ssl.sum('*', f, s) <= M[f] * y[f, s] for f in F for s in S), name='c8') m.addConstrs( - (zfs.sum(t, '*', s) <= quicksum([self.UE_jit[k] * w[s, k] for k in K]) + (shipped_farm_ssl.sum(t, '*', s) <= quicksum([self.upperbound_equip_proc_rate_jit[k] * w[s, k] for k in K]) for t in T for s in S), name='c9b') else: - m.addConstrs((If[t, f] == If[t - 1, f] + a[t, f] - zfs.sum(t, f, '*') - + m.addConstrs((inventory_level_farm[t, f] == inventory_level_farm[t - 1, f] + harvested[t, f] - shipped_farm_ssl.sum(t, f, '*') - z_jit.sum(t, f, '*') for t in T for f in F), name='c5') m.addConstrs( - (z_jit.sum(t, '*', '*') + zs.sum(t, '*') + penalty[t] == self.d[t] + (z_jit.sum(t, '*', '*') + shipped_ssl_refinery.sum(t, '*') + penalty[t] == self.demand[t] for t in T), name='c6') m.addConstrs( - (z_jit.sum('*', f, s) + zfs.sum('*', f, s) <= M[f] * y[f, s] + (z_jit.sum('*', f, s) + shipped_farm_ssl.sum('*', f, s) <= M[f] * y[f, s] for f in F for s in S), name='c8') - m.addConstrs((z_jit.sum(t, '*', s) + zfs.sum(t, '*', s) <= quicksum( - [self.UE_jit[k] * w[s, k] for k in K]) for t in T for s in S), + m.addConstrs((z_jit.sum(t, '*', s) + shipped_farm_ssl.sum(t, '*', s) <= quicksum( + [self.upperbound_equip_proc_rate_jit[k] * w[s, k] for k in K]) for t in T for s in S), name='c9b') logger.info("Model created. Begin solving.") @@ -148,25 +159,25 @@ def solve(self): cost_total = m.objVal gap = (cost_total - cost_total_lb) / cost_total # what does cost locations mean? - cost_loc = w.prod({(s, k): self.csk[s][k] for s in S for k in K}).getValue() + cost_loc = w.prod({(s, k): self.fixed_cost_ssls[s][k] for s in S for k in K}).getValue() - cost_op = zfs.sum().getValue() * self.c_op - cfs_dict = {(t, f, s): self.cfs[f][s] for t, f, s in setprod(T, F, S)} + cost_op = shipped_farm_ssl.sum().getValue() * self.operating_cost + cfs_dict = {(t, f, s): self.farm_ssl_trans_cost[f][s] for t, f, s in setprod(T, F, S)} # cost of transporting from f to s in time t - cost_tran_fs = zfs.prod(cfs_dict).getValue() + cost_tran_fs = shipped_farm_ssl.prod(cfs_dict).getValue() # what does the b stand for? - cost_tran_sb = zs.prod({(t, s): self.cs[s] + cost_tran_sb = shipped_ssl_refinery.prod({(t, s): self.ssl_refinery_trans_cost[s] for t in T for s in S}).getValue() if self.jit: - cost_op += z_jit.sum().getValue() * self.c_op_jit + cost_op += z_jit.sum().getValue() * self.operating_cost_jit cost_tran_fs += z_jit.prod(cfs_dict).getValue() - cost_tran_sb += z_jit.prod({(t, f, s): self.cs_jit[s] + cost_tran_sb += z_jit.prod({(t, f, s): self.ssl_refinery_jit_trans_cost[s] for t in T for f in F for s in S}).getValue() - cost_inv_S = Is.sum().getValue() * self.hs - cost_inv_F = If.sum().getValue() * self.hf + cost_inv_S = inventory_level_ssl.sum().getValue() * self.ssl_holding_cost + cost_inv_F = inventory_level_farm.sum().getValue() * self.farm_holding_cost K_cnt = dict(Counter(k for s in S for k in K if w[s, k].x > 0.5)) jit_amount = z_jit.sum().getValue() if self.jit else np.nan @@ -200,14 +211,14 @@ def solve(self): 'inv_f': cost_inv_F, 'inv_s': cost_inv_S, } - a_sum = float(a.sum()) + harvested_sum = float(harvested.sum()) summary['per_dry_Mg'] = { - k: v / a_sum + k: v / harvested_sum for k, v in summary['cost'].items() } summary['trans_amount'] = { - 'base_fs': zfs.sum().getValue(), - 'base_sb': zs.sum().getValue(), + 'base_fs': shipped_farm_ssl.sum().getValue(), + 'base_sb': shipped_ssl_refinery.sum().getValue(), 'jit': jit_amount } diff --git a/myapp.py b/myapp.py index d2aefd0..c36b495 100644 --- a/myapp.py +++ b/myapp.py @@ -11,9 +11,9 @@ from flask import Flask, render_template, request, send_from_directory, jsonify, send_file from algorithm.tsp import tsp from algorithm.s_bfl import s_bfl -from email_credentials import credentials -from flask_mail import Mail -from flask_mail import Message +# from email_credentials import credentials +# from flask_mail import Mail +# from flask_mail import Message from flask_cors import CORS class CustomFlask(Flask): @@ -27,20 +27,20 @@ class CustomFlask(Flask): app = CustomFlask(__name__,template_folder='') # This replaces your existing "app = Flask(__name__)" CORS(app) -c = credentials() -c.setPassword() +# c = credentials() +# c.setPassword() -app.config.update( - DEBUG = True, - MAIL_SERVER = 'smtp.gmail.com', - MAIL_PORT = 465, - MAIL_USE_SSL = True, - MAIL_USERNAME = 'robert.b.shelton.42@gmail.com', - MAIL_PASSWORD = c.password, -) +# app.config.update( +# DEBUG = True, +# MAIL_SERVER = 'smtp.gmail.com', +# MAIL_PORT = 465, +# MAIL_USE_SSL = True, +# MAIL_USERNAME = 'robert.b.shelton.42@gmail.com', +# MAIL_PASSWORD = c.password, +# ) -mail = Mail(app) +# mail = Mail(app) @app.route('/s-bfls/', methods=['POST']) def Sbfl(): @@ -50,13 +50,13 @@ def Sbfl(): my_s_bfl.solve() print(my_s_bfl.optimization_result) response = jsonify(my_s_bfl.optimization_result) - response.headers.add('Access-Control-Allow-Origin', '*') + # response.headers.add('Access-Control-Allow-Origin', '*') - msg = Message('S-BFLS', - sender="robert.b.shelton.42@gmail.com", - recipients=["robes98@vt.edu"]) - msg.body = "Thanks for using SBFLS! Attached are our results." - mail.send(msg) + # msg = Message('S-BFLS', + # sender="robert.b.shelton.42@gmail.com", + # recipients=["robes98@vt.edu"]) + # msg.body = "Thanks for using SBFLS! Attached are our results." + # mail.send(msg) return response @app.errorhandler(404)