pyaugmecon_test.py

from pyomo.environ import *
from pyaugmecon import PyAugmecon

import numpy as np
import pprint
# import highspy
print(SolverFactory.__dict__['_cls'].keys())

# set random seed
np.random.seed(100)
model_assign = ConcreteModel()

# Sets
model_assign.Tasks = Set(initialize=range(1, 4001))
model_assign.Groups = Set(initialize=range(1, 11))

# %%

# Parameters
planning_horizon = 6 * 60 * 60  # x hours in seconds

model_assign.Importance = Param(model_assign.Tasks, within=PositiveIntegers,
                         initialize=lambda model_assign, task: np.random.randint(1, 6))

model_assign.Competence = Param(model_assign.Tasks, model_assign.Groups, within=PositiveIntegers,
                         initialize=lambda model_assign, task, group: np.random.randint(1, 11))

model_assign.ProcessingTime = Param(model_assign.Tasks, within=PositiveIntegers,
                             initialize=lambda model_assign, task: np.random.randint(10, 301))

model_assign.CanDoTask = Param(model_assign.Tasks, model_assign.Groups,
                        within=Binary,
                        initialize=lambda model, task, group: np.random.choice([0, 1]))

model_assign.staffingroup = Param(model_assign.Groups, within=PositiveIntegers,
                           initialize=lambda model_assign, group: np.random.randint(6, 11))

# %%
# Variable
model_assign.Assign = Var(model_assign.Tasks, model_assign.Groups, within=Binary)

# %% [markdown]
# Constraints:
# 1. Can do the task
# 2. Each task can be only assigned to 1
# 3. Total time constraint

# %%
# Constraints
def _CanDoTask(model_assign, task, group):
    if model_assign.CanDoTask[task, group] == 1:
        return model_assign.Assign[task, group] <= model_assign.CanDoTask[task, group]
    else:
        return Constraint.Skip
model_assign.con_candotask = Constraint(model_assign.Tasks, model_assign.Groups, rule = _CanDoTask)

def _SingleAssignment(model_assign, task):
    return sum(model_assign.Assign[task, group] for group in model_assign.Groups) <= 1
model_assign.con_singleassign = Constraint(model_assign.Tasks, rule = _SingleAssignment)


def _TimeConstraint(model_assign, group):
    return sum(model_assign.Assign[task, group] * model_assign.ProcessingTime[task] for task in model_assign.Tasks) <= model_assign.staffingroup[group] * planning_horizon
model_assign.con_timeconstraint = Constraint(model_assign.Groups, rule = _TimeConstraint)


# %% [markdown]
# Objective:
# 1. max total competence
# 2. max total importance

# %%
# objective  1
def _obj_competence(model_assign):
    return sum(model_assign.Competence[task, group] * model_assign.Assign[task, group] for task in model_assign.Tasks for group in model_assign.Groups)
# model_assign.obj_competence = Objective(rule = _obj_competence, sense = maximize)


# objective 2
def _obj_importance(model_assign):
    return sum(model_assign.Importance[task] * model_assign.Assign[task, group] for task in model_assign.Tasks for group in model_assign.Groups)
# model_assign.obj_importance = Objective(rule = _obj_importance, sense = maximize)


# %%
model_assign.obj_list = ObjectiveList()
model_assign.obj_list.add(expr=_obj_competence(model_assign), sense=maximize)
model_assign.obj_list.add(expr=_obj_importance(model_assign), sense=maximize)

    # By default deactivate all the objective functions
for o in range(len(model_assign.obj_list)):
    model_assign.obj_list[o + 1].deactivate()

options = {
    "name": "model_type",
    "grid_points": 20,
    "solver_name": "cbc",
    "solver_io": None,
}

solver_options = {
    "MIPGap": None,
    "NonConvex": None,
}

py_augmecon = PyAugmecon(model_assign, options, solver_options)
py_augmecon.solve()