Hierarchical facility location model

[Mohammad Shoaib]

Hi 

I'm a beginner and have recently started using Pulp to solve a simple HFL problem. My solution is coming out to be infeasible. Can anyone point to the errors in my code and also direct me to some resource from where I could learn to use Pulp. Here is my code.

from pulp import *
import numpy as np
import pandas as pd
from scipy.spatial import distance

# for generating distance matrix
b1 = []
rows = 10            # number of rows
columns = 10         # number of columns
primary_demand = {}
secondary_demand = {}
for i in range(0, rows*columns):
    primary_demand[i] = 10
for i in range(0, rows*columns):
    secondary_demand[i] = 20

for i in range(0, rows):
    for j in range(0, columns):
        x1 = i
        y1 = j
        b1.append([x1, y1])

b1 = np.array(b1)
distanc = np.zeros([len(b1), len(b1)])

for i in range(len(b1)):
    x1 = b1[i]
    for j in range(len(b1)):
        x2 = b1[j]
        dst = round(distance.euclidean(x1, x2),  4)
        distanc[i][j] = dst


# defining lP parameters
t_distance = 1               # threshold distance
n = rows*columns             # i, j (number of grids)
facility_type = ["PHC", "CHC"]      # k
demand_type = ["Primary", "Secondary"]    # h (demand type)
facility_cost = {"PHC": 20, "CHC": 100}
demand = {"Primary": primary_demand, "Secondary": secondary_demand}
# demand = {"Primary":   {0: 10, 1: 10, 2: 10, 3: 10, 4: 10, 5:10, 6:10, 7:10, 8:10},
#           "Secondary": {0: 20, 1: 20, 2: 20, 3: 20, 4: 20, 5:20, 6:20, 7:20, 8:20}}

capacity = {"PHC": {"Primary": 50, "Secondary": 0},
            "CHC": {"Primary": 50, "Secondary": 100}}

# create model
model = LpProblem(name="Facility location model", sense=LpMinimize)

# defining variables
y_vars = LpVariable.dicts("y", [(i, j, k, h) for i in range(0, n) for j in range(0, n)
                                for k in facility_type for h in demand_type], lowBound=0,
                          upBound=1, cat=LpBinary)
x_vars = LpVariable.dicts('x', [(i, k) for i in range(0, n) for k in facility_type],
                          lowBound=0, upBound=1, cat=LpBinary)

# objective function setting
model += lpSum(facility_cost[k] * x_vars[(i, k)] for i in range(0, n) for k in facility_type)

# defining constraints
# 1 constraint: capacity constraint for each facility
for h in demand_type:
    for j in range(0, n):
        for k in facility_type:
            model += lpSum(demand[h][i] * y_vars[(i, j, k, h)] for i in range(0, n)) <=\
                     (x_vars[(j, k)] * capacity[k][h])

# 2 constraint: Ensuring all demand of a particular type is met
for h in demand_type:
    for i in range(0, n):
        model += demand[h][i] <= lpSum(y_vars[(i, j, k, h)] * demand[h][i] for j in range(0, n)
                                        for k in facility_type)

# 3 constraint : distance constraint
for h in demand_type:
    for k in facility_type:
        for i in range(0, n):
            for j in range(0, n):
                model += y_vars[(i, j, k, h)] * distanc[(i, j)] <= t_distance * (x_vars[(j, k)])

# 4 constraint: Demand from a grid can be allocated to only a single facility
for i in range(0, n):
    for k in facility_type:
        for h in demand_type:
            model += lpSum(y_vars[(i, j, k, h)] for j in range(0, n)) == 1

# 5 constraint: Demand from a grid can only be allocated to a grid with a facility
for i in range(0, n):
    for j in range(0, n):
        for k in facility_type:
            for h in demand_type:
                model += y_vars[(i, j, k, h)] <= x_vars[(i, k)]

# 6 constraint:
# for j in range (0,n):
#     if x_vars[j] == 1:
#         for i in range(0,n):
#             if i==j :
#                model += x_vars[j] - y_vars[(i,j)] <= 0

model.solve()

sol_array = []
print("Status : ", LpStatus[model.status])
for i in model.variables():
    if i.varValue == 1:
        sol_array.append([i.name, i.varValue])
        print(i.name, "=", i.varValue)
print("Objective func value is ", value(model.objective))
df = pd.DataFrame(sol_array)
df.to_excel(r'PHC.xls')
# print(df)