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): """ 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()