def load_init_state_nmpc(self, src_kind, **kwargs): """Loads ref state for set-point Args: src_kind (str): the kind of source **kwargs: Arbitrary keyword arguments. Returns: None Keyword Args: src_kind (str) : if == mod use reference model, otw use the internal dictionary ref (pyomo.core.base.PyomoModel.ConcreteModel): The reference model (default PlantPred) fe (int): The required finite element cp (int): The required collocation point """ # src_kind = kwargs.pop("src_kind", "mod") self.journalist("I", self._iteration_count, "load_init_state_nmpc", "Load State to nmpc src_kind=" + src_kind) ref = kwargs.pop("ref", None) fe = kwargs.pop("fe", self.nfe_tnmpc) cp = kwargs.pop("cp", self.ncp_tnmpc) if src_kind == "mod": if not ref: self.journalist("W", self._iteration_count, "load_init_state_nmpc", "No model was given") self.journalist("W", self._iteration_count, "load_init_state_nmpc", "No update on state performed") sys.exit() for x in self.states: xic = getattr(self.olnmpc, x + "_ic") xvar = getattr(self.olnmpc, x) xsrc = getattr(ref, x) for j in self.state_vars[x]: xic[j].value = value(xsrc[(fe, cp) + j]) xvar[(0, 0) + j].set_value(value(xsrc[(fe, cp) + j])) else: state_dict = kwargs.pop("state_dict", None) if state_dict == "real": #: Load from the real state dict for x in self.states: xic = getattr(self.olnmpc, x + "_ic") xvar = getattr(self.olnmpc, x) for j in self.state_vars[x]: xic[j].value = self.curr_rstate[(x, j)] xvar[(0, 0) + j].set_value(self.curr_rstate[(x, j)]) elif state_dict == "estimated": #: Load from the estimated state dict for x in self.states: xic = getattr(self.olnmpc, x + "_ic") xvar = getattr(self.olnmpc, x) for j in self.state_vars[x]: xic[j].value = self.curr_estate[(x, j)] xvar[(0, 0) + j].set_value(self.curr_estate[(x, j)]) elif state_dict == "predicted": #: Load from the estimated state dict for x in self.states: xic = getattr(self.olnmpc, x + "_ic") xvar = getattr(self.olnmpc, x) for j in self.state_vars[x]: try: xic[j].value = self.curr_pstate[(x, j)] except KeyError: print(self.curr_pstate) xvar[(0, 0) + j].set_value(self.curr_pstate[(x, j)]) else: self.journalist("W", self._iteration_count, "load_init_state_nmpc", "No dict w/state was specified") self.journalist("W", self._iteration_count, "load_init_state_nmpc", "No update on state performed") raise ValueError("Unexpeted state_dict %s" % state_dict)
def _build_equality_set(m): """Construct an equality set map. Maps all variables to the set of variables that are linked to them by equality. Mapping takes place using id(). That is, if you have x = y, then you would have id(x) -> ComponentSet([x, y]) and id(y) -> ComponentSet([x, y]) in the mapping. """ #: dict: map of var UID to the set of all equality-linked var UIDs eq_var_map = ComponentMap() relevant_vars = ComponentSet() for constr in m.component_data_objects(ctype=Constraint, active=True, descend_into=True): # Check to make sure the constraint is of form v1 - v2 == 0 if (value(constr.lower) == 0 and value(constr.upper) == 0 and constr.body.polynomial_degree() == 1): repn = generate_canonical_repn(constr.body) # only take the variables with nonzero coefficients vars_ = [v for i, v in enumerate(repn.variables) if repn.linear[i]] if (len(vars_) == 2 and sorted(l for l in repn.linear if l) == [-1, 1]): # this is an a == b constraint. v1 = vars_[0] v2 = vars_[1] set1 = eq_var_map.get(v1, ComponentSet([v1])) set2 = eq_var_map.get(v2, ComponentSet([v2])) relevant_vars.update([v1, v2]) set1.update(set2) # set1 is now the union for v in set1: eq_var_map[v] = set1 return eq_var_map, relevant_vars
def update_var(self, var): """ Update a variable in the solver's model. This will update bounds, fix/unfix the variable as needed, and update the variable type. Parameters ---------- var: Var """ if var.is_indexed(): for child_var in var.values(): self.compile_var(child_var) return if var not in self._pyomo_var_to_solver_var_map: raise ValueError('The Var provided to compile_var needs to be added first: {0}'.format(var)) cplex_var = self._pyomo_var_to_solver_var_map[var] vtype = self._cplex_vtype_from_var(var) if var.is_fixed(): lb = var.value ub = var.value else: lb = -self._cplex.infinity ub = self._cplex.infinity if var.has_lb(): lb = value(var.lb) if var.has_ub(): ub = value(var.ub) self._solver_model.variables.set_lower_bounds(cplex_var, lb) self._solver_model.variables.set_upper_bounds(cplex_var, ub) self._solver_model.variables.set_types(cplex_var, vtype)
def cycle_ics(self, curr_fe): """Cycles the initial conditions of the initializing model. Take the values of states (initializing model) at t=last and patch them into t=0. Check: https://github.com/dthierry/cappresse/blob/pyomodae-david/nmpc_mhe/aux/utils.py fe_cp function! """ #For checking whether jump happens in right element: #print('*'* 20) #print("Current Finite element [cycle_ics]{}".format(curr_fe)) #comment out these lines? #print('*' * 20) ts = getattr(self.mod, self.time_set) t_last = t_ij(ts, 0, self.ncp) #Inclusion of discrete jumps: (CS) ttgt = getattr(self.tgt, self.time_set) for i in self.dvs_names: dv = getattr(self.mod, i) for s in self.remaining_set[i]: if s is None: val = value(dv[t_last]) dv[0].set_value(val) if not dv[0].fixed: dv[0].fix() continue for k in s: k = k if isinstance(k, tuple) else (k,) val = value(dv[(t_last,) + k]) dv[(0,) + k].set_value(val) if not dv[(0,) + k].fixed: dv[(0,) + k].fix()
def update_var(self, var): """ Update a variable in the solver's model. This will update bounds, fix/unfix the variable as needed, and update the variable type. Parameters ---------- var: Var """ if var.is_indexed(): for child_var in var.values(): self.update_var(child_var) return if var not in self._pyomo_var_to_solver_var_map: raise ValueError( 'The Var provided to update_var needs to be added first: {0}'. format(var)) gurobipy_var = self._pyomo_var_to_solver_var_map[var] vtype = self._gurobi_vtype_from_var(var) if var.is_fixed(): lb = var.value ub = var.value else: lb = -self._gurobipy.GRB.INFINITY ub = self._gurobipy.GRB.INFINITY if var.has_lb(): lb = value(var.lb) if var.has_ub(): ub = value(var.ub) gurobipy_var.setAttr('lb', lb) gurobipy_var.setAttr('ub', ub) gurobipy_var.setAttr('vtype', vtype)
def _add_var(self, var): varname = self._symbol_map.getSymbol(var, self._labeler) vtype = self._cplex_vtype_from_var(var) if var.has_lb(): lb = value(var.lb) else: lb = -self._cplex.infinity if var.has_ub(): ub = value(var.ub) else: ub = self._cplex.infinity self._solver_model.variables.add(lb=[lb], ub=[ub], types=[vtype], names=[varname]) self._pyomo_var_to_solver_var_map[var] = varname self._solver_var_to_pyomo_var_map[varname] = var self._pyomo_var_to_ndx_map[var] = self._ndx_count self._ndx_count += 1 self._referenced_variables[var] = 0 if var.is_fixed(): self._solver_model.variables.set_lower_bounds(varname, var.value) self._solver_model.variables.set_upper_bounds(varname, var.value)
def test_pickle(self): v = variable() e = noclone(v) self.assertEqual(type(e), noclone) self.assertIs(type(e.expr), variable) eup = pickle.loads(pickle.dumps(e)) self.assertEqual(type(eup), noclone) self.assertTrue(e is not eup) self.assertIs(type(eup.expr), variable) self.assertIs(type(e.expr), variable) self.assertTrue(eup.expr is not e.expr) del e del v v = variable(value=1) b = block() b.v = v eraw = b.v + 1 b.e = 1 + noclone(eraw) bup = pickle.loads(pickle.dumps(b)) self.assertTrue(isinstance(bup.e, NumericValue)) self.assertEqual(value(bup.e), 3.0) b.v.value = 2 self.assertEqual(value(b.e), 4.0) self.assertEqual(value(bup.e), 3.0) bup.v.value = -1 self.assertEqual(value(b.e), 4.0) self.assertEqual(value(bup.e), 1.0) self.assertIs(b.v.parent, b) self.assertIs(bup.v.parent, bup) del b.v
def update_var(self, var): """Update a single variable in the solver's model. This will update bounds, fix/unfix the variable as needed, and update the variable type. Parameters ---------- var: Var (scalar Var or single _VarData) """ # see PR #366 for discussion about handling indexed # objects and keeping compatibility with the # pyomo.kernel objects #if var.is_indexed(): # for child_var in var.values(): # self.update_var(child_var) # return if var not in self._pyomo_var_to_solver_var_map: raise ValueError('The Var provided to update_var needs to be added first: {0}'.format(var)) gurobipy_var = self._pyomo_var_to_solver_var_map[var] vtype = self._gurobi_vtype_from_var(var) if var.is_fixed(): lb = var.value ub = var.value else: lb = -self._gurobipy.GRB.INFINITY ub = self._gurobipy.GRB.INFINITY if var.has_lb(): lb = value(var.lb) if var.has_ub(): ub = value(var.ub) gurobipy_var.setAttr('lb', lb) gurobipy_var.setAttr('ub', ub) gurobipy_var.setAttr('vtype', vtype)
def update_targets_nmpc(self): """Use the reference model to update the current state and control targets dictionaries""" for x in self.states: xvar = getattr(self.SteadyRef2, x) for j in self.state_vars[x]: self.curr_state_target[(x, j)] = value(xvar[0, 1, j]) for u in self.u: uvar = getattr(self.SteadyRef2, u) self.curr_u_target[u] = value(uvar[0])
def _apply_to(self, instance, tmp=False): """Apply the transformation. Args: instance (Block): the block on which to search for x == y constraints. Note that variables may be located anywhere in the model. tmp (bool, optional): Whether the bound modifications will be temporary Returns: None """ if tmp and not hasattr(instance, '_tmp_propagate_original_bounds'): instance._tmp_propagate_original_bounds = Suffix( direction=Suffix.LOCAL) eq_var_map, relevant_vars = _build_equality_set(instance) processed = ComponentSet() # Go through each variable in an equality set to propagate the variable # bounds to all equality-linked variables. for var in relevant_vars: # If we have already processed the variable, skip it. if var in processed: continue var_equality_set = eq_var_map.get(var, ComponentSet([var])) #: variable lower bounds in the equality set lbs = [v.lb for v in var_equality_set if v.has_lb()] max_lb = max(lbs) if len(lbs) > 0 else None #: variable upper bounds in the equality set ubs = [v.ub for v in var_equality_set if v.has_ub()] min_ub = min(ubs) if len(ubs) > 0 else None # Check for error due to bound cross-over if max_lb is not None and min_ub is not None and max_lb > min_ub: # the lower bound is above the upper bound. Raise a ValueError. # get variable with the highest lower bound v1 = next(v for v in var_equality_set if v.lb == max_lb) # get variable with the lowest upper bound v2 = next(v for v in var_equality_set if v.ub == min_ub) raise ValueError( 'Variable {} has a lower bound {} ' ' > the upper bound {} of variable {}, ' 'but they are linked by equality constraints.'.format( v1.name, value(v1.lb), value(v2.ub), v2.name)) for v in var_equality_set: if tmp: # TODO warn if overwriting instance._tmp_propagate_original_bounds[v] = (v.lb, v.ub) v.setlb(max_lb) v.setub(min_ub) processed.update(var_equality_set)
def main(): ipopt = SolverFactory('ipopt') ipopt.solve(model, tee=True) for key in model.X.keys(): print('X[{}]=\t{}'.format(key, value(model.X[key]))) for key in model.P.keys(): print('P[{}]=\t{}'.format(key, value(model.P[key]))) for key in model.Z.keys(): print('Z[{}]=\t{}'.format(key, value(model.Z[key]))) print('OILPUR =\t{}'.format(value(model.OILPUR)))
def is_binary(self): """Returns :const:`True` when the domain type is :class:`IntegerSet` and the bounds are within [0,1].""" lb, ub = self.bounds return self.is_integer() and \ (lb is not None) and \ (ub is not None) and \ (value(lb) >= 0) and \ (value(ub) <= 1)
def _apply_to(self, model): """Apply the transformation to the given model.""" m = model for constr in m.component_data_objects(ctype=Constraint, active=True, descend_into=True): # Check if the constraint is k * x + c1 <= c2 or c2 <= k * x + c1 if constr.body.polynomial_degree() == 1: repn = generate_canonical_repn(constr.body) if repn.variables is not None and len(repn.variables) == 1: var = repn.variables[0] const = repn.constant if repn.constant is not None else 0 coef = float(repn.linear[0]) if coef == 0: # This can happen when a one element of a bilinear term # is fixed to zero. Obviously, do not divide by zero. pass else: if constr.upper is not None: newbound = (value(constr.upper) - const) / coef if coef > 0: var.setub( min(var.ub, newbound) if var. ub is not None else newbound) elif coef < 0: var.setlb( max(var.lb, newbound) if var. lb is not None else newbound) if constr.lower is not None: newbound = (value(constr.lower) - const) / coef if coef > 0: var.setlb( max(var.lb, newbound) if var. lb is not None else newbound) elif coef < 0: var.setub( min(var.ub, newbound) if var. ub is not None else newbound) constr.deactivate() # Sometimes deactivating the constraint will remove a # variable from all active constraints, so that it won't be # updated during the optimization. Therefore, we need to # shift the value of var as necessary in order to keep it # within its implied bounds, as the constraint we are # deactivating is not an invalid constraint, but rather we # are moving its implied bound directly onto the variable. if (var.has_lb() and var.value is not None and var.value < var.lb): var.set_value(var.lb) if (var.has_ub() and var.value is not None and var.value > var.ub): var.set_value(var.ub)
def compute_QR_nmpc(self, src="plant", n=-1, **kwargs): """Using the current state & control targets, computes the Qk and Rk matrices (diagonal) Strategy: take the inverse of the absolute difference between reference and current state such that every offset in the objective is normalized or at least dimensionless Args: src (str): The source of the update (default mhe) (mhe or plant) n (int): The exponent of the weight""" check_values = kwargs.pop("check_values", False) if check_values: max_w_value = kwargs.pop("max_w_value", 1e+06) min_w_value = kwargs.pop("min_w_value", 0.0) self.update_targets_nmpc() if src == "mhe": for x in self.states: for j in self.state_vars[x]: k = self.xmpc_key[(x, j)] temp = abs(self.curr_estate[(x, j)] - self.curr_state_target[(x, j)]) if temp > 1e-08: self.olnmpc.Q_nmpc[k].value = temp**n else: self.olnmpc.Q_nmpc[k].value = max_w_value self.olnmpc.xmpc_ref_nmpc[k].value = self.curr_state_target[(x, j)] elif src == "plant": for x in self.states: for j in self.state_vars[x]: k = self.xmpc_key[(x, j)] # self.olnmpc.Q_nmpc[k].value = abs(self.curr_rstate[(x, j)] - self.curr_state_target[(x, j)])**n temp = abs(self.curr_rstate[(x, j)] - self.curr_state_target[(x, j)]) if temp > 1e-08: self.olnmpc.Q_nmpc[k].value = temp ** n else: self.olnmpc.Q_nmpc[k].value = max_w_value self.olnmpc.xmpc_ref_nmpc[k].value = self.curr_state_target[(x, j)] k = 0 for u in self.u: self.olnmpc.R_nmpc[k].value = abs(self.curr_u[u] - self.curr_u_target[u])**n self.olnmpc.umpc_ref_nmpc[k].value = self.curr_u_target[u] k += 1 if check_values: for k in self.olnmpc.xmpcS_nmpc: if value(self.olnmpc.Q_nmpc[k]) < min_w_value: self.olnmpc.Q_nmpc[k].value = min_w_value if value(self.olnmpc.Q_nmpc[k]) > max_w_value: self.olnmpc.Q_nmpc[k].value = max_w_value k = 0 for u in self.u: if value(self.olnmpc.R_nmpc[k]) < min_w_value: self.olnmpc.R_nmpc[k].value = min_w_value if value(self.olnmpc.R_nmpc[k]) > max_w_value: self.olnmpc.R_nmpc[k].value = max_w_value k += 1
def _apply_to(self, instance): """Apply the transformation. Args: instance (Block): the block on which to search for x == sum(var) constraints. Note that variables may be located anywhere in the model. Returns: None """ for constr in instance.component_data_objects(ctype=Constraint, active=True, descend_into=True): if not constr.body.polynomial_degree() == 1: continue # constraint not linear. Skip. repn = generate_canonical_repn(constr.body) if (constr.has_ub() and ( (repn.constant is None and value(constr.upper) == 0) or repn.constant == value(constr.upper) )): # term1 + term2 + term3 + ... <= 0 # all var terms need to be non-negative if all( # variable has 0 coefficient coef == 0 or # variable is non-negative and has non-negative coefficient (repn.variables[i].has_lb() and value(repn.variables[i].lb) >= 0 and coef >= 0) or # variable is non-positive and has non-positive coefficient (repn.variables[i].has_ub() and value(repn.variables[i].ub) <= 0 and coef <= 0) for i, coef in enumerate(repn.linear)): for i, coef in enumerate(repn.linear): if not coef == 0: repn.variables[i].fix(0) continue if (constr.has_lb() and ( (repn.constant is None and value(constr.lower) == 0) or repn.constant == value(constr.lower) )): # term1 + term2 + term3 + ... >= 0 # all var terms need to be non-positive if all( # variable has 0 coefficient coef == 0 or # variable is non-negative and has non-positive coefficient (repn.variables[i].has_lb() and value(repn.variables[i].lb) >= 0 and coef <= 0) or # variable is non-positive and has non-negative coefficient (repn.variables[i].has_ub() and value(repn.variables[i].ub) <= 0 and coef >= 0) for i, coef in enumerate(repn.linear)): for i, coef in enumerate(repn.linear): if not coef == 0: repn.variables[i].fix(0)
def _apply_to(self, instance, tmp=False): """Apply the transformation. Args: instance (Block): the block on which to search for x == y constraints. Note that variables may be located anywhere in the model. tmp (bool, optional): Whether the variable fixing will be temporary Returns: None Raises: ValueError: if two fixed variables x = y have different values. """ if tmp and not hasattr(instance, '_tmp_propagate_fixed'): instance._tmp_propagate_fixed = ComponentSet() eq_var_map, relevant_vars = _build_equality_set(instance) #: ComponentSet: The set of all fixed variables fixed_vars = ComponentSet((v for v in relevant_vars if v.fixed)) newly_fixed = _detect_fixed_variables(instance) if tmp: instance._tmp_propagate_fixed.update(newly_fixed) fixed_vars.update(newly_fixed) processed = ComponentSet() # Go through each fixed variable to propagate the 'fixed' status to all # equality-linked variabes. for v1 in fixed_vars: # If we have already processed the variable, skip it. if v1 in processed: continue eq_set = eq_var_map.get(v1, ComponentSet([v1])) for v2 in eq_set: if (v2.fixed and value(v1) != value(v2)): raise ValueError( 'Variables {} and {} have conflicting fixed ' 'values of {} and {}, but are linked by ' 'equality constraints.'.format(v1.name, v2.name, value(v1), value(v2))) elif not v2.fixed: v2.fix(value(v1)) if tmp: instance._tmp_propagate_fixed.add(v2) # Add all variables in the equality set to the set of processed # variables. processed.update(eq_set)
def _apply_to(self, instance, **kwargs): """Apply the transformation. Args: instance: Pyomo model object to transform. Kwargs: tmp: True to store a set of transformed constraints for future reversion of the transformation ignore_infeasible: True to skip over trivial constraints that are infeasible instead of raising a ValueError. tol: tolerance on constraint violations """ tmp = kwargs.pop('tmp', False) ignore_infeasible = kwargs.pop('ignore_infeasible', False) tol = kwargs.pop('tolerance', 1E-13) if tmp and not hasattr(instance, '_tmp_trivial_deactivated_constrs'): instance._tmp_trivial_deactivated_constrs = ComponentSet() # Trivial constraints are those that do not contain any variables, ie. # the polynomial degree is 0 trivial_constraints = (c for c in instance.component_data_objects( ctype=Constraint, active=True, descend_into=True) if c.body.polynomial_degree() == 0) for constr in trivial_constraints: # We need to check each constraint to sure that it is not violated. # Check if the lower bound is violated outside a given tolerance if (constr.has_lb() and value(constr.body) + tol <= value(constr.lower)): # Trivial constraint is infeasible. if ignore_infeasible: # do nothing, move on to next constraint continue else: raise ValueError( 'Trivial constraint {} violates LB {} ≤ BODY {}.'. format(constr.name, value(constr.lower), value(constr.body))) # Check if the upper bound is violated outside a given tolerance if (constr.has_ub() and value(constr.body) >= value(constr.upper) + tol): # Trivial constraint is infeasible. if ignore_infeasible: # do nothing, move on to next constraint continue else: raise ValueError( 'Trivial constraint {} violates BODY {} ≤ UB {}.'. format(constr.name, value(constr.body), value(constr.upper))) # Constraint is not infeasible. Deactivate it. if tmp: instance._tmp_trivial_deactivated_constrs.add(constr) constr.deactivate()
def _transformDisjunctionData(self, disjunction): # the sum of all the indicator variable values of disjuncts in the # disjunction logical_sum = sum( value(disj.indicator_var) for disj in disjunction.disjuncts) # Check that the disjunctions are not being fixed to an infeasible # realization. if disjunction.xor and not logical_sum == 1: # for XOR disjunctions, the sum of all disjunct values should be 1 raise GDP_Error( "Disjunction %s violated. " "Expected 1 disjunct to be active, but %s were active." % (disjunction.name, logical_sum)) elif not logical_sum >= 1: # for non-XOR disjunctions, the sum of all disjunct values should # be at least 1 raise GDP_Error("Disjunction %s violated. " "Expected at least 1 disjunct to be active, " "but none were active.") else: # disjunction is in feasible realization. Deactivate it. disjunction.deactivate() # Process the disjuncts associatd with the disjunction that have not # already been transformed. for disj in ComponentSet( disjunction.disjuncts) - self._transformedDisjuncts: self._transformDisjunctData(disj) # Update the set of transformed disjuncts with those from this # disjunction self._transformedDisjuncts.update(disjunction.disjuncts)
def _detect_fixed_variables(m): """Detect fixed variables due to constraints of form var = const.""" new_fixed_vars = ComponentSet() for constr in m.component_data_objects(ctype=Constraint, active=True, descend_into=True): if constr.equality and constr.body.polynomial_degree() == 1: repn = generate_canonical_repn(constr.body) if len(repn.variables) == 1 and repn.linear[0]: var = repn.variables[0] coef = float(repn.linear[0]) const = repn.constant if repn.constant is not None else 0 var_val = (value(constr.lower) - value(const)) / coef var.fix(var_val) new_fixed_vars.add(var) return new_fixed_vars
def _apply_to(self, instance, **kwargs): """Apply the transformation. Args: instance: Pyomo model object to transform. Kwargs: tmp: True to store the set of transformed variables and their old values so that they can be restored. tol: tolerance on bound equality (LB == UB) """ tmp = kwargs.pop('tmp', False) tol = kwargs.pop('tolerance', 1E-13) if tmp: instance._xfrm_detect_fixed_vars_old_values = ComponentMap() for var in instance.component_data_objects(ctype=Var, descend_into=True): if var.fixed or var.lb is None or var.ub is None: # if the variable is already fixed, or if it is missing a # bound, we skip it. continue if fabs(value(var.lb - var.ub)) <= tol: if tmp: instance._xfrm_detect_fixed_vars_old_values[var] = \ var.value var.fix(var.lb)
def __call__(self, exception=True): try: return sum(value(c, exception=exception) * \ v(exception=exception) for v,c in self.terms) except (ValueError, TypeError): if exception: raise ValueError("one or more terms " "could not be evaluated") return None
def log_close_to_bounds(m, tol=1E-6): """Print the variables and constraints that are near their bounds. Fixed variables and equality constraints are excluded from this analysis. Args: m (Block): Pyomo block or model to check tol (float): bound tolerance """ for var in m.component_data_objects( ctype=Var, descend_into=True): if var.fixed: continue if (var.has_lb() and var.has_ub() and fabs(value(var.ub - var.lb)) <= 2 * tol): continue # if the bounds are too close, skip. if var.has_lb() and fabs(value(var.lb - var)) <= tol: logger.info('{} near LB of {}'.format(var.name, value(var.lb))) elif var.has_ub() and fabs(value(var.ub - var)) <= tol: logger.info('{} near UB of {}'.format(var.name, value(var.ub))) for constr in m.component_data_objects( ctype=Constraint, descend_into=True, active=True): if not constr.equality: if (constr.has_ub() and fabs(value(constr.body - constr.upper)) <= tol): logger.info('{} near UB'.format(constr.name)) if (constr.has_lb() and fabs(value(constr.body - constr.lower)) <= tol): logger.info('{} near LB'.format(constr.name))
def validate(self, equal_slopes_tolerance=1e-6): """ Validate this piecewise linear function by verifying various properties of the breakpoints and values lists (e.g., that the list of breakpoints is nondecreasing). Args: equal_slopes_tolerance (float): Tolerance used check if consecutive slopes are nearly equal. If any are found, validation will fail. Default is 1e-6. Returns: int: a function characterization code (see \ :func:`util.characterize_function`) Raises: PiecewiseValidationError: if validation fails """ breakpoints = [value(x) for x in self._breakpoints] values = [value(x) for x in self._values] if not is_nondecreasing(breakpoints): raise PiecewiseValidationError( "The list of breakpoints is not nondecreasing: %s" % (str(breakpoints))) ftype, slopes = characterize_function(breakpoints, values) for i in xrange(1, len(slopes)): if (slopes[i-1] is not None) and \ (slopes[i] is not None) and \ (abs(slopes[i-1] - slopes[i]) <= equal_slopes_tolerance): raise PiecewiseValidationError( "Piecewise function validation detected slopes " "of consecutive line segments to be within %s " "of one another. This may cause numerical issues. " "To avoid this error, set the 'equal_slopes_tolerance' " "keyword to a smaller value or disable validation." % (equal_slopes_tolerance)) return ftype
def change_setpoint(self, ref_state, **kwargs): """Change the update the ref_state dictionary, and attempt to find a new reference state""" if ref_state: self.ref_state = ref_state else: if not ref_state: self.journalist("W", self._iteration_count, "change_setpoint", "No reference state was given, using default") if not self.ref_state: self.journalist("W", self._iteration_count, "change_setpoint", "No default reference state was given, exit") sys.exit() #: Create a dictionary whose keys are the same as the ref state weights_ref = dict.fromkeys(self.ref_state.keys()) model_ref = self.PlantSample #: I am not sure about this for i in self.ref_state.keys(): v = getattr(model_ref, i[0]) vkey = i[1] vss0 = value(v[(0, 1) + vkey]) val = abs(self.ref_state[i] - vss0) if val < 1e-09: val = 1e+06 else: val = 1/val weights_ref[i] = val #: If no weights are passed, use the reference that we have just calculated weights = kwargs.pop("weights", weights_ref) ofexp = 0.0 for i in self.ref_state.keys(): v = getattr(self.SteadyRef2, i[0]) vkey = i[1] ofexp += weights[i] * (v[(0, 1) + vkey] - self.ref_state[i]) ** 2 self.SteadyRef2.obfun_SteadyRef2.set_value(ofexp) self.solve_dyn(self.SteadyRef2, iter_max=500, stop_if_nopt=True, **kwargs) for i in self.ref_state.keys(): v = getattr(self.SteadyRef2, i[0]) vkey = i[1] val = value(v[(0, 1) + vkey]) print("target {:}".format(i[0]), "key {:}".format(i[1]), "weight {:f}".format(weights[i]), "value {:f}".format(val)) self.update_targets_nmpc()
def _warm_start(self): var_names = [] var_values = [] for pyomo_var, cplex_var in self._pyomo_var_to_solver_var_map.items(): if pyomo_var.value is not None: var_names.append(cplex_var) var_values.append(value(pyomo_var)) if len(var_names): self._solver_model.MIP_starts.add([var_names, var_values], self._solver_model.MIP_starts.effort_level.auto)
def _apply_to(self, instance, overwrite=False): """Apply the transformation. Kwargs: overwrite: if False, transformation will not overwrite existing variable values. """ for var in instance.component_data_objects( ctype=Var, descend_into=True): if var.fixed: continue if var.value is not None and not overwrite: continue if var.lb is not None and value(var.lb) > 0: var.set_value(value(var.lb)) elif var.ub is not None and value(var.ub) < 0: var.set_value(value(var.ub)) else: var.set_value(0)
def redo_cost_calculation(m): commitments_costs = [] for c in m.c: commitment_cost = 0 for j in m.j: ems_power_in_j = sum(m.power[d, j] for d in m.d) ems_power_deviation = ems_power_in_j - m.commitment_quantity[c, j] if value(ems_power_deviation) >= 0: commitment_cost += round( value(ems_power_deviation * m.up_price[c, j]), 3) else: commitment_cost += round( value(ems_power_deviation * m.down_price[c, j]), 3) commitments_costs.append(commitment_cost) return commitments_costs
def uslack(self): """Upper slack (ub - value). Returns :const:`None` if the variable value is :const:`None`.""" val = self.value if val is None: return None ub = self.ub if ub is None: ub = _pos_inf else: ub = value(ub) return ub - val
def lslack(self): """Lower slack (value - lb). Returns :const:`None` if the variable value is :const:`None`.""" val = self.value if val is None: return None lb = self.lb if lb is None: lb = _neg_inf else: lb = value(lb) return val - lb
def __init__(self, var_list, symbol_map): self.binary = [] self.ints = [] self.positive = [] self.reals = [] # categorize variables for var in var_list: v = symbol_map.getObject(var) if v.is_binary(): self.binary.append(var) elif v.is_integer(): if (v.has_lb() and (value(v.lb) >= 0)) and \ (v.has_ub() and (value(v.ub) <= 1)): self.binary.append(var) else: self.ints.append(var) elif value(v.lb) == 0: self.positive.append(var) else: self.reals.append(var)