Esempio n. 1
0
 def __init__(self, model=None, env=None):
     Solver.__init__(self)
     if env:
         self.problem = GurobiModel(env=env)
     else:
         self.problem = GurobiModel()
     self.set_logging(False)
     self.set_parameters(default_parameters)
     if model:
         self.build_problem(model)
Esempio n. 2
0
 def __init__(self, model=None):
     Solver.__init__(self)
     self.problem = GurobiModel()
     self.set_logging()
     self.set_parameters(default_parameters)
     if model:
         self.build_problem(model)
Esempio n. 3
0
def additive_optimization(model):
    """Optimize the model exactly, but just based on marginal utilities of
    individual migrant-locality pairs and assuming additivity.

    Args:
        model (models.Model): The submodular model to use

    Returns:
        pair (locality_per_agent,best_value) of type (list of int/None, float).
        The first component is the matching, the second its queried value in
        the model.
    """
    gm = GurobiModel()
    gm.setParam("OutputFlag", False)

    variables = []
    matching = [None for _ in range(model.num_agents)]
    objective = 0
    for i in range(model.num_agents):
        agent_vars = []
        for l in range(len(model.locality_caps)):
            matching[i] = l
            utility = model.utility_for_matching(matching)
            matching[i] = None

            v = gm.addVar(vtype=GRB.INTEGER, name=f"m_{i}_{l}")
            gm.addConstr(v >= 0)
            gm.addConstr(v <= 1)
            agent_vars.append(v)

            objective += utility * v

        variables.append(agent_vars)
        gm.addConstr(quicksum(agent_vars) <= 1)

    for l in range(len(model.locality_caps)):
        gm.addConstr(quicksum(variables[i][l] for i in range(model.num_agents))
                     <= model.locality_caps[l])

    gm.setObjective(objective, GRB.MAXIMIZE)
    gm.optimize()

    assert gm.status == GRB.OPTIMAL
    for i in range(model.num_agents):
        for l in range(len(model.locality_caps)):
            if variables[i][l].X > 0.5:
                matching[i] = l
                break

    return matching, model.utility_for_matching(matching, False)
Esempio n. 4
0
def build_gurobi_model(case):
    G, B = case.G, case.B
    P = real(case.demands)
    Q = imag(case.demands)
    branches = case.branch_list
    n = len(case.demands)
    vhat = case.vhat
    s2 = 2**.5
    gens = {bus: gen.v for bus, gen in case.gens.items()}
    del gens[0]

    m = GurobiModel("jabr")
    u = [m.addVar(name='u_%d' % i) for i in range(n)]
    R = {(i, j): m.addVar(name='R_%d_%d' % (i, j)) for i, j in branches}
    I = {(i, j): m.addVar(lb=-GRB.INFINITY, name='I_%d_%d' % (i, j))
         for i, j in branches}
    for i, j in branches:
        R[j, i] = R[i, j]
        I[j, i] = I[i, j]
    m.update()
    m.addConstr(u[0] == vhat * vhat / s2, 'u0')
    for gen, v in gens.iteritems():
        m.addConstr(u[gen] == v * v / s2, 'u%d' % gen)
    for i, j in branches:
        m.addQConstr(2 * u[i] * u[j] >= R[i, j] * R[i, j] + I[i, j] * I[i, j],
                     'cone_%d_%d' % (i, j))
    k = lambda i: (j for j in B[i, :].nonzero()[1])
    s = lambda i, j: 1 if i < j else -1
    for i in range(1, n):
        m.addConstr(
            -s2 * u[i] * G[i, :].sum() +
            quicksum(G[i, j] * R[i, j] + B[i, j] * s(i, j) * I[i, j]
                     for j in k(i)) == P[i], 'real_flow_%d_%d' % (i, j))
        if i in gens:
            continue
        m.addConstr(
            s2 * u[i] * B[i, :].sum() +
            quicksum(-B[i, j] * R[i, j] + G[i, j] * s(i, j) * I[i, j]
                     for j in k(i)) == Q[i], 'reac_flow_%d_%d' % (i, j))
    m.setObjective(quicksum(R[i, j] for i, j in branches), sense=GRB.MAXIMIZE)
    m.params.outputFlag = 0
    #m.params.barQCPConvTol = 5e-10
    m.optimize()
    if m.status != 2:
        raise ValueError("gurobi failed to converge: %s (check log)" %
                         m.status)
    u_opt = [x.getAttr('x') for x in u]
    R_opt = {(i, j): x.getAttr('x') for (i, j), x in R.items()}
    I_opt = {(i, j): x.getAttr('x') for (i, j), x in I.items()}
    return u_opt, R_opt, I_opt