def construct(self, data=None): if __debug__ and logger.isEnabledFor(logging.DEBUG): #pragma:nocover logger.debug( "Constructing Port, name=%s, from data=%s" % (self.name, data) ) if self._constructed: return timer = ConstructionTimer(self) self._constructed = True # Construct _PortData objects for all index values if self.is_indexed(): self._initialize_members(self._index) else: self._data[None] = self self._initialize_members([None]) # get rid of these references self._rule = None self._initialize = None self._implicit = None self._extends = None # especially important as this is another port timer.report()
def construct(self, data=None): """Initialize the Arc""" if __debug__ and logger.isEnabledFor(logging.DEBUG): logger.debug("Constructing Arc %s" % self.name) if self._constructed: return timer = ConstructionTimer(self) self._constructed = True if self._rule is None and self._init_vals is None: # No construction rule or values specified return elif self._rule is not None and self._init_vals is not None: raise ValueError( "Cannot specify rule along with source/destination/ports " "keywords for arc '%s'" % self.name) self_parent = self._parent() if not self.is_indexed(): if self._rule is None: tmp = self._init_vals tmp["directed"] = self._init_directed else: try: tmp = self._rule(self_parent) except Exception: err = sys.exc_info()[1] logger.error( "Rule failed when generating values for " "arc %s:\n%s: %s" % (self.name, type(err).__name__, err)) raise tmp = _iterable_to_dict(tmp, self._init_directed, self.name) self._setitem_when_not_present(None, tmp) else: if self._init_vals is not None: raise IndexError( "Arc '%s': Cannot initialize multiple indices " "of an arc with single ports" % self.name) for idx in self._index: try: tmp = apply_indexed_rule(self, self._rule, self_parent, idx) except Exception: err = sys.exc_info()[1] logger.error( "Rule failed when generating values for " "arc %s with index %s:\n%s: %s" % (self.name, str(idx), type(err).__name__, err)) raise tmp = _iterable_to_dict(tmp, self._init_directed, self.name) self._setitem_when_not_present(idx, tmp) timer.report()
def construct(self, data=None): if __debug__ and logger.isEnabledFor(logging.DEBUG): #pragma:nocover logger.debug("Constructing %s '%s', from data=%s", self.__class__.__name__, self.name, str(data)) if self._constructed: #pragma:nocover return timer = ConstructionTimer(self) # _self_rule = self._rule self._rule = None super(Complementarity, self).construct() self._rule = _self_rule # if _self_rule is None and self._expr is None: # No construction rule or expression specified. return # if not self.is_indexed(): # # Scalar component # if _self_rule is None: self.add(None, self._expr) else: try: tmp = _self_rule(self.parent_block()) self.add(None, tmp) except Exception: err = sys.exc_info()[1] logger.error( "Rule failed when generating expression for " "complementarity %s:\n%s: %s" % ( self.name, type(err).__name__, err ) ) raise else: if not self._expr is None: raise IndexError( "Cannot initialize multiple indices of a Complementarity " "component with a single expression") _self_parent = self._parent() for idx in self._index: try: tmp = apply_indexed_rule( self, _self_rule, _self_parent, idx ) self.add(idx, tmp) except Exception: err = sys.exc_info()[1] logger.error( "Rule failed when generating expression for " "complementarity %s with index %s:\n%s: %s" % ( self.name, idx, type(err).__name__, err ) ) raise timer.report()
def construct(self, data=None): """ Apply the rule to construct values in this set """ if __debug__ and logger.isEnabledFor(logging.DEBUG): logger.debug( "Constructing Expression, name=%s, from data=%s" % (self.name, str(data))) if self._constructed: return timer = ConstructionTimer(self) self._constructed = True _init_expr = self._init_expr _init_rule = self._init_rule # # We no longer need these # self._init_expr = None # Utilities like DAE assume this stays around #self._init_rule = None if not self.is_indexed(): self._data[None] = self # # Construct and initialize members # if _init_rule is not None: # construct and initialize with a rule if self.is_indexed(): for key in self._index: self.add(key, apply_indexed_rule( self, _init_rule, self._parent(), key)) else: self.add(None, _init_rule(self._parent())) else: # construct and initialize with a value if _init_expr.__class__ is dict: for key in self._index: if key not in _init_expr: continue self.add(key, _init_expr[key]) else: for key in self._index: self.add(key, _init_expr) timer.report()
def construct(self, data=None): if __debug__ and logger.isEnabledFor(logging.DEBUG): #pragma:nocover try: name = str(self.name) except: name = type(self) if logger.isEnabledFor(logging.DEBUG): logger.debug("Constructing Alias, name=%s, " "from data=%s", name, str(data)) if self._constructed: return timer = ConstructionTimer(self) self._constructed = True timer.report()
def construct(self, values=None): """ Initialize set data """ if self._constructed: return timer = ConstructionTimer(self) self._constructed=True # # We call value() here for cases like Expressions, mutable # Params and the like # self._start_val = value(self._start) self._end_val = value(self._end) self._step_val = value(self._step) # # The set generates integer values if the starting value, # step and end value are all integers. Otherwise, the set # generates real values. # if type(self._start_val) is int and type(self._step) is int and type(self._end_val) is int: self.domain = Integers else: self.domain = Reals # # Compute the set length and upper bound # if self.filter is None and self.validate is None: # # Directly compute the number of elements in the set, from # which the upper-bound is computed. # self._len = int(math.floor((self._end_val-self._start_val+self._step_val+1e-7)//self._step_val)) ub = self._start_val + (self._len-1)*self._step_val else: # # Iterate through the set to compute the upper bound # and number of elements. # ub = self._start_val ctr=0 for i in self: ub = i ctr += 1 self._len = ctr # # Set the bounds information # self._bounds = (self._start_val, ub) timer.report()
def construct(self, values=None): """ Constructs a :py:class:`ContinuousSet` component """ timer = ConstructionTimer(self) OrderedSimpleSet.construct(self, values) for val in self.value: if type(val) is tuple: raise ValueError("ContinuousSet cannot contain tuples") if val.__class__ not in native_numeric_types: raise ValueError("ContinuousSet can only contain numeric " "values") if self._bounds is None: raise ValueError("ContinuousSet '%s' must have at least two values" " indicating the range over which a differential " "equation is to be discretized" % self.name) # If bounds were set using pyomo parameters, get their values lb = value(self._bounds[0]) ub = value(self._bounds[1]) self._bounds = (lb, ub) if self._bounds[0].__class__ not in native_numeric_types: raise ValueError("Bounds on ContinuousSet must be numeric values") if self._bounds[1].__class__ not in native_numeric_types: raise ValueError("Bounds on ContinuousSet must be numeric values") # TBD: If a user specifies bounds they will be added to the set # unless the user specified bounds have been overwritten during # OrderedSimpleSet construction. This can lead to some unintuitive # behavior when the ContinuousSet is both initialized with values and # bounds are specified. The current implementation is consistent # with how 'Set' treats this situation. if self._bounds[0] not in self.value: self.add(self._bounds[0]) self._sort() if self._bounds[1] not in self.value: self.add(self._bounds[1]) self._sort() if len(self) < 2: raise ValueError("ContinuousSet '%s' must have at least two values" " indicating the range over which a differential " "equation is to be discretized" % self.name) self._fe = sorted(self) timer.report()
def construct(self, data=None): """ Constructs this component, applying rule if it exists. """ if __debug__ and logger.isEnabledFor(logging.DEBUG): logger.debug("Constructing suffix %s", self.name) if self._constructed is True: return timer = ConstructionTimer(self) self._constructed = True if self._rule is not None: self.update_values(self._rule(self._parent())) timer.report()
def construct(self, data=None): if __debug__ and logger.isEnabledFor(logging.DEBUG): #pragma:nocover logger.debug( "Constructing Connector, name=%s, from data=%s" % (self.name, data) ) if self._constructed: return timer = ConstructionTimer(self) self._constructed=True # # Construct _ConnectorData objects for all index values # if self.is_indexed(): self._initialize_members(self._index) else: self._data[None] = self self._initialize_members([None]) timer.report()
def construct(self, data=None): """ Apply the rule to construct values in this set """ if __debug__ and logger.isEnabledFor(logging.DEBUG): #pragma:nocover logger.debug("Constructing Action, name="+self.name) # if self._constructed: #pragma:nocover return timer = ConstructionTimer(self) self._constructed=True # if not self.is_indexed(): # Scalar component self._rule(self._parent()) else: # Indexed component for index in self._index: apply_indexed_rule(self, self._rule, self._parent(), index) timer.report()
def construct(self, data=None): """ Construct the expression(s) for this complementarity condition. """ generate_debug_messages = __debug__ and logger.isEnabledFor(logging.DEBUG) if generate_debug_messages: #pragma:nocover logger.debug("Constructing complementarity list %s", self.name) if self._constructed: #pragma:nocover return timer = ConstructionTimer(self) _self_rule = self._rule self._constructed=True if _self_rule is None: return # _generator = None _self_parent = self._parent() if inspect.isgeneratorfunction(_self_rule): _generator = _self_rule(_self_parent) elif inspect.isgenerator(_self_rule): _generator = _self_rule if _generator is None: while True: val = self._nconditions + 1 if generate_debug_messages: #pragma:nocover logger.debug(" Constructing complementarity index "+str(val)) expr = apply_indexed_rule( self, _self_rule, _self_parent, val ) if expr is None: raise ValueError( "Complementarity rule returned None " "instead of ComplementarityList.End" ) if (expr.__class__ is tuple and expr == ComplementarityList.End): return self.add(expr) else: for expr in _generator: if expr is None: raise ValueError( "Complementarity generator returned None " "instead of ComplementarityList.End" ) if (expr.__class__ is tuple and expr == ComplementarityList.End): return self.add(expr) timer.report()
def construct(self, data=None): if __debug__ and logger.isEnabledFor(logging.DEBUG): logger.debug("Constructing disjunction %s" % (self.name)) if self._constructed: return timer = ConstructionTimer(self) self._constructed=True _self_parent = self.parent_block() if not self.is_indexed(): if self._init_rule is not None: expr = self._init_rule(_self_parent) elif self._init_expr is not None: expr = self._init_expr else: timer.report() return if expr is None: raise ValueError( _rule_returned_none_error % (self.name,) ) if expr is Disjunction.Skip: timer.report() return self._data[None] = self self._setitem_when_not_present( None, expr ) elif self._init_expr is not None: raise IndexError( "Disjunction '%s': Cannot initialize multiple indices " "of a disjunction with a single disjunction list" % (self.name,) ) elif self._init_rule is not None: _init_rule = self._init_rule for ndx in self._index: try: expr = apply_indexed_rule(self, _init_rule, _self_parent, ndx) except Exception: err = sys.exc_info()[1] logger.error( "Rule failed when generating expression for " "disjunction %s with index %s:\n%s: %s" % (self.name, str(ndx), type(err).__name__, err)) raise if expr is None: _name = "%s[%s]" % (self.name, str(idx)) raise ValueError( _rule_returned_none_error % (_name,) ) if expr is Disjunction.Skip: continue self._setitem_when_not_present(ndx, expr) timer.report()
def construct(self, data=None): """ Apply the rule to construct values in this set """ if __debug__ and logger.isEnabledFor(logging.DEBUG): #pragma:nocover logger.debug("Constructing Check, name="+self.name) # if self._constructed: #pragma:nocover return timer = ConstructionTimer(self) self._constructed=True # if not self.is_indexed(): # Scalar component res = self._rule(self._parent()) if not res: raise ValueError("BuildCheck %r identified error" % self.name) else: # Indexed component for index in self._index: res = apply_indexed_rule(self, self._rule, self._parent(), index) if not res: raise ValueError("BuildCheck %r identified error with index %r" % (self.name, str(index))) timer.report()
def construct(self, data=None): """Construct this component.""" if __debug__ and logger.isEnabledFor(logging.DEBUG): #pragma:nocover try: name = str(self.name) except: # Some Var components don't have a name yet, so just use # the type name = type(self) if logger.isEnabledFor(logging.DEBUG): logger.debug( "Constructing Variable, name=%s, from data=%s" % (name, str(data))) if self._constructed: return timer = ConstructionTimer(self) self._constructed=True # # Construct _VarData objects for all index values # if not self.is_indexed(): self._data[None] = self self._initialize_members((None,)) elif self._dense: # This loop is optimized for speed with pypy. # Calling dict.update((...) for ...) is roughly # 30% slower self_weakref = weakref_ref(self) for ndx in self._index: cdata = self._ComponentDataClass( domain=self._domain_init_value, component=None) cdata._component = self_weakref self._data[ndx] = cdata #self._initialize_members((ndx,)) self._initialize_members(self._index) timer.report()
def construct(self, data=None): """ Construct the expression(s) for this constraint. """ if __debug__ and logger.isEnabledFor(logging.DEBUG): logger.debug("Constructing constraint %s" % (self.name)) if self._constructed: return timer = ConstructionTimer(self) self._constructed=True _init_expr = self._init_expr _init_rule = self.rule # # We no longer need these # self._init_expr = None # Utilities like DAE assume this stays around #self.rule = None if (_init_rule is None) and \ (_init_expr is None): # No construction role or expression specified. return _self_parent = self._parent() if not self.is_indexed(): # # Scalar component # if _init_rule is None: tmp = _init_expr else: try: tmp = _init_rule(_self_parent) except Exception: err = sys.exc_info()[1] logger.error( "Rule failed when generating expression for " "constraint %s:\n%s: %s" % (self.name, type(err).__name__, err)) raise self._setitem_when_not_present(None, tmp) else: if _init_expr is not None: raise IndexError( "Constraint '%s': Cannot initialize multiple indices " "of a constraint with a single expression" % (self.name,) ) for ndx in self._index: try: tmp = apply_indexed_rule(self, _init_rule, _self_parent, ndx) except Exception: err = sys.exc_info()[1] logger.error( "Rule failed when generating expression for " "constraint %s with index %s:\n%s: %s" % (self.name, str(ndx), type(err).__name__, err)) raise self._setitem_when_not_present(ndx, tmp) timer.report()
def construct(self, data=None): """ Construct the expression(s) for this objective. """ if is_debug_set(logger): logger.debug("Constructing objective %s" % (self.name)) if self._constructed: return timer = ConstructionTimer(self) self._constructed = True _init_expr = self._init_expr _init_sense = self._init_sense _init_rule = self.rule # # We no longer need these # self._init_expr = None self._init_sense = None # Utilities like DAE assume this stays around #self.rule = None if (_init_rule is None) and \ (_init_expr is None): # No construction rule or expression specified. return _self_parent = self._parent() if not self.is_indexed(): # # Scalar component # if _init_rule is None: tmp = _init_expr else: try: tmp = _init_rule(_self_parent) except Exception: err = sys.exc_info()[1] logger.error("Rule failed when generating expression for " "objective %s:\n%s: %s" % (self.name, type(err).__name__, err)) raise if self._setitem_when_not_present(None, tmp) is not None: self.set_sense(_init_sense) else: if _init_expr is not None: raise IndexError("Cannot initialize multiple indices of an " "objective with a single expression") for ndx in self._index: try: tmp = apply_indexed_rule(self, _init_rule, _self_parent, ndx) except Exception: err = sys.exc_info()[1] logger.error( "Rule failed when generating expression for" " objective %s with index %s:\n%s: %s" % (self.name, str(ndx), type(err).__name__, err)) raise ans = self._setitem_when_not_present(ndx, tmp) if ans is not None: ans.set_sense(_init_sense) timer.report()
def construct(self, data=None): """ Construct this component """ assert data is None # because I don't know why it's an argument generate_debug_messages = is_debug_set(logger) if self._constructed is True: #pragma:nocover return if generate_debug_messages: #pragma:nocover logger.debug("Constructing SOSConstraint %s", self.name) timer = ConstructionTimer(self) self._constructed = True if self._rule is None: if self._sosSet is None and self.is_indexed(): if generate_debug_messages: #pragma:nocover logger.debug( " Cannot construct " + self.name + ". No rule is defined and no SOS sets are defined.") else: if not self.is_indexed(): if self._sosSet is None: if getattr(self._sosVars.index_set(), 'isordered', lambda *x: False)(): _sosSet = {None: list(self._sosVars.index_set())} else: _sosSet = {None: set(self._sosVars.index_set())} else: _sosSet = {None: self._sosSet} else: _sosSet = self._sosSet for index, sosSet in six.iteritems(_sosSet): if generate_debug_messages: #pragma:nocover logger.debug(" Constructing " + self.name + " index " + str(index)) if self._sosLevel == 2: # # Check that the sets are ordered. # ordered = False if type( sosSet ) is list or sosSet is UnindexedComponent_set or len( sosSet) == 1: ordered = True if hasattr(sosSet, 'isordered') and sosSet.isordered(): ordered = True if not ordered: raise ValueError( "Cannot define a SOS over an unordered index.") variables = [self._sosVars[idx] for idx in sosSet] if self._sosWeights is not None: weights = [self._sosWeights[idx] for idx in sosSet] else: weights = None self.add(index, variables, weights) else: _self_rule = self._rule _self_parent = self._parent() for index in self._index: try: tmp = apply_indexed_rule(self, _self_rule, _self_parent, index) except Exception: err = sys.exc_info()[1] logger.error( "Rule failed when generating expression for " "sos constraint %s with index %s:\n%s: %s" % (self.name, str(index), type(err).__name__, err)) raise if tmp is None: raise ValueError( "SOSConstraint rule returned None instead of SOSConstraint.Skip for index %s" % str(index)) if type(tmp) is tuple: if tmp is SOSConstraint.Skip: continue # tmp is a tuple of variables, weights self.add(index, tmp[0], tmp[1]) else: # tmp is a list of variables self.add(index, tmp) timer.report()
def construct(self, data=None): """ Initialize this component. A parameter is constructed using the initial data or the data loaded from an external source. We first set all the values based on self._rule, and then allow the data dictionary to overwrite anything. Note that we allow an undefined Param value to be constructed. We throw an exception if a user tries to use an uninitialized Param. """ if __debug__ and logger.isEnabledFor(logging.DEBUG): #pragma:nocover logger.debug("Constructing Param, name=%s, from data=%s" % (self.name, str(data))) # if self._constructed: return timer = ConstructionTimer(self) # # If the default value is a simple type, we check it versus # the domain. # val = self._default_val if val is not _NotValid \ and type(val) in native_types \ and val not in self.domain: raise ValueError( "Default value (%s) is not valid for Param %s domain %s" % (str(val), self.name, self.domain.name)) # # Flag that we are in the "during construction" phase # self._constructed = None # # Step #1: initialize data from rule value # if self._rule is not _NotValid: self._initialize_from(self._rule) # # Step #2: allow any user-specified (external) data to override # the initialization # if data is not None: try: for key, val in iteritems(data): self._setitem_when_not_present(self._validate_index(key), val) except Exception: msg = sys.exc_info()[1] if type(data) is not dict: raise ValueError( "Attempting to initialize parameter=%s with data=%s.\n" "\tData type is not a dictionary, and a dictionary is " "expected." % (self.name, str(data))) else: raise RuntimeError( "Failed to set value for param=%s, index=%s, value=%s." "\n\tsource error message=%s" % (self.name, str(key), str(val), str(msg))) # # Flag that things are fully constructed now (and changing an # inmutable Param is now an exception). # self._constructed = True # populate all other indices with default data # (avoids calling _set_contains on self._index at runtime) if self._dense_initialize: self.to_dense_data() timer.report()
def test_raw_construction_timer(self): a = ConstructionTimer(None) self.assertIn("ConstructionTimer object for NoneType (unknown); ", str(a))
def construct(self, data=None): """ Initialize this component. A parameter is constructed using the initial data or the data loaded from an external source. We first set all the values based on self._rule, and then allow the data dictionary to overwrite anything. Note that we allow an undefined Param value to be constructed. We throw an exception if a user tries to use an uninitialized Param. """ if __debug__ and logger.isEnabledFor(logging.DEBUG): #pragma:nocover logger.debug("Constructing Param, name=%s, from data=%s" % ( self.name, str(data) )) # if self._constructed: return timer = ConstructionTimer(self) # # If the default value is a simple type, we check it versus # the domain. # val = self._default_val if val is not _NotValid \ and type(val) in native_types \ and val not in self.domain: raise ValueError( "Default value (%s) is not valid for Param %s domain %s" % (str(val), self.name, self.domain.name)) # # Flag that we are in the "during construction" phase # self._constructed = None # # Step #1: initialize data from rule value # if self._rule is not _NotValid: self._initialize_from(self._rule) # # Step #2: allow any user-specified (external) data to override # the initialization # if data is not None: try: for key, val in iteritems(data): self._setitem_when_not_present( self._validate_index(key), val) except Exception: msg = sys.exc_info()[1] if type(data) is not dict: raise ValueError( "Attempting to initialize parameter=%s with data=%s.\n" "\tData type is not a dictionary, and a dictionary is " "expected." % (self.name, str(data)) ) else: raise RuntimeError( "Failed to set value for param=%s, index=%s, value=%s." "\n\tsource error message=%s" % (self.name, str(key), str(val), str(msg)) ) # # Flag that things are fully constructed now (and changing an # inmutable Param is now an exception). # self._constructed = True # populate all other indices with default data # (avoids calling _set_contains on self._index at runtime) if self._dense_initialize: self.to_dense_data() timer.report()
def construct(self, data=None): """ Construct the expression(s) for this logical constraint. """ if __debug__ and logger.isEnabledFor(logging.DEBUG): logger.debug("Constructing logical constraint %s" % self.name) if self._constructed: return timer = ConstructionTimer(self) self._constructed = True _init_expr = self._init_expr _init_rule = self.rule # # We no longer need these # self._init_expr = None # Utilities like DAE assume this stays around # self.rule = None if (_init_rule is None) and \ (_init_expr is None): # No construction role or expression specified. return _self_parent = self._parent() if not self.is_indexed(): # # Scalar component # if _init_rule is None: tmp = _init_expr else: try: tmp = _init_rule(_self_parent) except Exception: err = sys.exc_info()[1] logger.error("Rule failed when generating expression for " "logical constraint %s:\n%s: %s" % (self.name, type(err).__name__, err)) raise self._setitem_when_not_present(None, tmp) else: if _init_expr is not None: raise IndexError( "LogicalConstraint '%s': Cannot initialize multiple indices " "of a logical constraint with a single expression" % (self.name, )) for ndx in self._index: try: tmp = apply_indexed_rule(self, _init_rule, _self_parent, ndx) except Exception: err = sys.exc_info()[1] logger.error( "Rule failed when generating expression for " "logical constraint %s with index %s:\n%s: %s" % (self.name, str(ndx), type(err).__name__, err)) raise self._setitem_when_not_present(ndx, tmp) timer.report()
def construct(self, data=None): """ Construct this component """ assert data is None # because I don't know why it's an argument generate_debug_messages \ = __debug__ and logger.isEnabledFor(logging.DEBUG) if self._constructed is True: #pragma:nocover return if generate_debug_messages: #pragma:nocover logger.debug("Constructing SOSConstraint %s",self.name) timer = ConstructionTimer(self) self._constructed = True if self._rule is None: if self._sosSet is None and self.is_indexed(): if generate_debug_messages: #pragma:nocover logger.debug(" Cannot construct "+self.name+". No rule is defined and no SOS sets are defined.") else: if not self.is_indexed(): if self._sosSet is None: if getattr(self._sosVars.index_set(), 'ordered', False): _sosSet = {None: list(self._sosVars.index_set())} else: _sosSet = {None: set(self._sosVars.index_set())} else: _sosSet = {None: self._sosSet} else: _sosSet = self._sosSet for index, sosSet in six.iteritems(_sosSet): if generate_debug_messages: #pragma:nocover logger.debug(" Constructing "+self.name+" index "+str(index)) if self._sosLevel == 2: # # Check that the sets are ordered. # ordered=False if type(sosSet) is list or sosSet is UnindexedComponent_set or len(sosSet) == 1: ordered=True if hasattr(sosSet, 'ordered') and sosSet.ordered: ordered=True if type(sosSet) is _IndexedOrderedSetData: ordered=True if not ordered: raise ValueError("Cannot define a SOS over an unordered index.") variables = [self._sosVars[idx] for idx in sosSet] if self._sosWeights is not None: weights = [self._sosWeights[idx] for idx in sosSet] else: weights = None self.add(index, variables, weights) else: _self_rule = self._rule _self_parent = self._parent() for index in self._index: try: tmp = apply_indexed_rule(self, _self_rule, _self_parent, index) except Exception: err = sys.exc_info()[1] logger.error( "Rule failed when generating expression for " "sos constraint %s with index %s:\n%s: %s" % ( self.name, str(index), type(err).__name__, err ) ) raise if tmp is None: raise ValueError("SOSConstraint rule returned None instead of SOSConstraint.Skip for index %s" % str(index)) if type(tmp) is tuple: if tmp is SOSConstraint.Skip: continue # tmp is a tuple of variables, weights self.add(index, tmp[0], tmp[1]) else: # tmp is a list of variables self.add(index, tmp) timer.report()
def construct(self, data=None): """ Construct the expression(s) for this objective. """ if self._constructed: return self._constructed = True timer = ConstructionTimer(self) if is_debug_set(logger): logger.debug("Constructing objective %s" % (self.name)) rule = self.rule try: # We do not (currently) accept data for constructing Objectives index = None assert data is None if rule is None: # If there is no rule, then we are immediately done. return if rule.constant() and self.is_indexed(): raise IndexError( "Objective '%s': Cannot initialize multiple indices " "of an objective with a single expression" % (self.name,) ) block = self.parent_block() if rule.contains_indices(): # The index is coming in externally; we need to validate it for index in rule.indices(): ans = self.__setitem__(index, rule(block, index)) if ans is not None: self[index].set_sense(self._init_sense(block, index)) elif not self.index_set().isfinite(): # If the index is not finite, then we cannot iterate # over it. Since the rule doesn't provide explicit # indices, then there is nothing we can do (the # assumption is that the user will trigger specific # indices to be created at a later time). pass else: # Bypass the index validation and create the member directly for index in self.index_set(): ans = self._setitem_when_not_present( index, rule(block, index)) if ans is not None: ans.set_sense(self._init_sense(block, index)) except Exception: err = sys.exc_info()[1] logger.error( "Rule failed when generating expression for " "Objective %s with index %s:\n%s: %s" % (self.name, str(index), type(err).__name__, err)) raise finally: timer.report()
def construct(self, data=None): """ Construct the _VarData objects for this variable """ if self._constructed: return self._constructed = True timer = ConstructionTimer(self) if is_debug_set(logger): logger.debug("Constructing Variable %s" % (self.name, )) # Note: define 'index' to avoid 'variable referenced before # assignment' in the error message generated in the 'except:' # block below. index = None try: # We do not (currently) accept data for constructing Variables assert data is None if not self.index_set().isfinite() and self._dense: # Note: if the index is not finite, then we cannot # iterate over it. This used to be fatal; now we # just warn logger.warning( "Var '%s' indexed by a non-finite set, but declared " "with 'dense=True'. Reverting to 'dense=False' as " "it is not possible to make this variable dense. " "This warning can be suppressed by specifying " "'dense=False'" % (self.name, )) self._dense = False if (self._rule_init is not None and self._rule_init.contains_indices()): # Historically we have allowed Vars to be initialized by # a sparse map (i.e., a dict containing only some of the # keys). We will wrap the incoming initializer to map # KeyErrors to None self._rule_init = DefaultInitializer(self._rule_init, None, KeyError) # The index is coming in externally; we need to validate it for index in self._rule_init.indices(): self[index] # If this is a dense object, we need to ensure that it # has been filled in. if self._dense: for index in self.index_set(): if index not in self._data: self._getitem_when_not_present(index) elif not self.is_indexed(): # As there is only a single VarData to populate, just do # so and bypass all special-case testing below self._getitem_when_not_present(None) elif self._dense: # Special case: initialize every VarData. For the # initializers that are constant, we can avoid # re-calling (and re-validating) the inputs in certain # cases. To support this, we will create the first # _VarData and then use it as a template to initialize # (constant portions of) every VarData so as to not # repeat all the domain/bounds validation. try: ref = self._getitem_when_not_present( next(iter(self.index_set()))) except StopIteration: # Empty index! return call_domain_rule = not self._rule_domain.constant() call_bounds_rule = self._rule_bounds is not None and ( not self._rule_bounds.constant()) call_init_rule = self._rule_init is not None and ( not self._rule_init.constant() # If either the domain or bounds change, then we # need to re-verify the initial value, even if it is # constant: or call_domain_rule or call_bounds_rule) # Initialize all the component datas with the common data for index in self.index_set(): self._data[index] = self._ComponentDataClass.copy(ref) # NOTE: This is a special case where a key, value pair is # added to the _data dictionary without calling # _getitem_when_not_present, which is why we need to set the # index here. self._data[index]._index = index # Now go back and initialize any index-specific data block = self.parent_block() if call_domain_rule: for index, obj in self._data.items(): # We can directly set the attribute (not the # property) because the SetInitializer ensures # that the value is a proper Set. obj._domain = self._rule_domain(block, index) if call_bounds_rule: for index, obj in self._data.items(): obj.lower, obj.upper = self._rule_bounds(block, index) if call_init_rule: for index, obj in self._data.items(): obj.set_value(self._rule_init(block, index)) else: # non-dense indexed var with generic # (non-index-containing) initializer: nothing to do pass except Exception: err = sys.exc_info()[1] logger.error("Rule failed when initializing variable for " "Var %s with index %s:\n%s: %s" % (self.name, str(index), type(err).__name__, err)) raise finally: timer.report()