Changeset 5841


Ignore:
Timestamp:
Jun 4, 2012 4:04:56 PM (7 years ago)
Author:
zbfried
Message:

Changed model.create to be able to take a dictionary holding model data

Location:
coopr.pyomo/trunk/coopr/pyomo/base
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • coopr.pyomo/trunk/coopr/pyomo/base/PyomoModel.py

    r5831 r5841  
    370370        elif type(arg) is ModelData:
    371371            self._load_model_data(arg, namespaces, profile_memory=profile_memory)
     372            return True
     373        elif type(arg) is dict:
     374            self._load_model_data(ModelData(data_dict=arg,model=self), namespaces, profile_memory=profile_memory)
    372375            return True
    373376        elif type(arg) is coopr.opt.SolverResults:
     
    504507                            #
    505508                            #self.active_components(Var)[component_name] = var
    506 
    507             declaration = self.components[component_name]
    508             if component_name in modeldata._default.keys():
    509                 if declaration.type() is Set:
    510                     declaration.set_default(self._tuplize(modeldata._default[component_name], declaration))
    511                 else:
    512                     declaration.set_default(modeldata._default[component_name])
    513             data = None
    514 
    515             for namespace in namespaces:
    516                 if component_name in modeldata._data.get(namespace,{}).keys():
    517                     if declaration.type() is Set:
    518                         data = self._tuplize(modeldata._data[namespace][component_name],
    519                                              declaration)
    520                     else:
    521                         data = modeldata._data[namespace][component_name]
    522                 if not data is None:
    523                     break
    524 
    525             if __debug__:
    526                 if logger.isEnabledFor(logging.DEBUG):
    527                     msg = "About to generate '%s' with data: %s"
    528                     print msg % ( declaration.name, str(data) )
    529                     self.pprint()
    530 
    531             try:
    532                 declaration.construct(data)
    533             except:
    534                 logger.error("constructing declaration '%s' from data=%s failed",
    535                              str(declaration.name), str(data).strip() )
    536                 raise
    537 
    538             if (pympler_available is True) and (profile_memory >= 2):
    539                 mem_used = muppy.get_size(muppy.get_objects())
    540                 print "      Total memory = %d bytes following construction of component=%s" % (mem_used, component_name)
    541 
    542             if (pympler_available is True) and (profile_memory >= 3):
    543                 gc.collect()
    544                 mem_used = muppy.get_size(muppy.get_objects())
    545                 print "      Total memory = %d bytes following construction of component=%s (after garbage collection)" % (mem_used, component_name)
     509            self._initialize_component(modeldata, namespaces, component_name, profile_memory)
    546510
    547511        if (pympler_available is True) and (profile_memory >= 2):
     
    552516
    553517            print ""
     518
     519
     520    def _initialize_component(self, modeldata, namespaces, component_name, profile_memory):
     521        #print "\ninitializing component_name = ",component_name
     522        #print "namespaces = ",namespaces
     523
     524        component_name_split = component_name.split(".")
     525        declaration = self.components[component_name_split[0]]
     526        for i in xrange(1,len(component_name_split)):
     527            declaration = getattr(declaration,component_name_split[i])
     528
     529        #print declaration.type()
     530        #print declaration.is_constructed()
     531
     532        if component_name in modeldata._default.keys():
     533            #print "component_name in modeldata._default.keys()"
     534            if declaration.type() is Set:
     535                declaration.set_default(self._tuplize(modeldata._default[component_name], declaration))
     536            else:
     537                declaration.set_default(modeldata._default[component_name])
     538        data = None
     539       
     540        for namespace in namespaces:
     541            #print modeldata._data.get(namespace,{}).keys()
     542            if component_name_split[-1] in modeldata._data.get(namespace,{}).keys():
     543                if declaration.type() is Set:
     544                    data = self._tuplize(modeldata._data[namespace][component_name_split[-1]],
     545                                         declaration)
     546                else:
     547                    data = modeldata._data[namespace][component_name_split[-1]]
     548            if not data is None:
     549                break
     550
     551        if __debug__:
     552            if logger.isEnabledFor(logging.DEBUG):
     553                msg = "About to generate '%s' with data: %s"
     554                print msg % ( declaration.name, str(data) )
     555                self.pprint()
     556
     557        try:
     558            if data is not None and type(data) is not dict:
     559                data = {None:data}
     560            #print "constructing data = ",data,"\n"
     561            declaration.construct(data)
     562        except:
     563            logger.error("constructing declaration '%s' from data=%s failed",
     564                         str(declaration.name), str(data).strip() )
     565            raise
     566
     567        if declaration.type() is Block:
     568            #print "Found a block with keys:"
     569            #print "\t",declaration.components.keys()
     570            for key in declaration.components:
     571                #print "key = ",key
     572                namespaces.append(declaration.block_namespace())
     573                self._initialize_component(modeldata, namespaces, declaration.block_namespace()+str(key), profile_memory)
     574
     575
     576
     577        if (pympler_available is True) and (profile_memory >= 2):
     578            mem_used = muppy.get_size(muppy.get_objects())
     579            print "      Total memory = %d bytes following construction of component=%s" % (mem_used, component_name)
     580
     581        if (pympler_available is True) and (profile_memory >= 3):
     582            gc.collect()
     583            mem_used = muppy.get_size(muppy.get_objects())
     584            print "      Total memory = %d bytes following construction of component=%s (after garbage collection)" % (mem_used, component_name)
     585
    554586
    555587    def _load_solution( self, soln, symbol_map,
     
    729761
    730762@coopr.core.coopr_api(namespace='pyomo.model')
    731 def default_constructor(data, model=None, filename=None, name=None, namespace=None, namespaces=None, preprocess=True, profile_memory=0, clone=None):
     763def default_constructor(data, model=None, filename=None, data_dict={}, name=None, namespace=None, namespaces=None, preprocess=True, profile_memory=0, clone=None):
    732764    """
    733765    Create a concrete instance of this Model, possibly using data
     
    740772        filename:           The name of a Pyomo Data File that will be used to load
    741773                                data into the model.
     774        data_dict:          A dictionary containing initialization data for the model
     775                                to be used if there is no filename
    742776        name:               The name given to the model.
    743777        namespace:          A namespace used to select data.
     
    767801
    768802        if namespaces is None or len(namespaces) == 0:
    769             instance.load(filename, namespaces=[None], profile_memory=profile_memory)
     803            if filename is None:
     804                instance.load(data_dict, namespaces=[None], profile_memory=profile_memory)
     805            else:
     806                instance.load(filename, namespaces=[None], profile_memory=profile_memory)
    770807        else:
    771             instance.load(filename, namespaces=namespaces+[None], profile_memory=profile_memory)
     808            if filename is None:
     809                instance.load(data_dict, namespaces=namespaces+[None], profile_memory=profile_memory)
     810            else:
     811                instance.load(filename, namespaces=namespaces+[None], profile_memory=profile_memory)
    772812    else:
    773813        if clone:
  • coopr.pyomo/trunk/coopr/pyomo/base/PyomoModelData.py

    r5802 r5841  
    5050                self.add(filename, **kwds)
    5151                self.read()
     52        elif 'data_dict' in kwds:
     53            if not kwds['data_dict'] is None:
     54                self.read_dict(data_dict=kwds['data_dict'])
    5255        elif len(kwds) > 0:
    5356            raise ValueError, "Unknown options: %s" % str(kwds.keys())
     
    5962    #
    6063    def initialize(self, component, data, namespace=None):
     64        #print "initializing ",namespace,"\t",component,"\t",data
     65        #print self._data
     66        if namespace not in self._data.keys():
     67            self._data[namespace]={}
    6168        self._data[namespace][component] = data
    6269
     
    109116            if __debug__:
    110117                logger.debug("Done.")
     118
     119    def read_dict(self, model=None, data_dict={}, level=None):
     120       
     121        #print "\nread_dict begin level = ",level
     122        #print "data_dict = ",data_dict
     123
     124        if model is not None:
     125            self._model=model
     126
     127        if self._model is None:
     128            raise ValueError, "Cannot read model data without a model"
     129       
     130        for key in data_dict:
     131            #print "key = ",key
     132            if type(data_dict[key]) is dict:
     133                if level is None:
     134                    self.read_dict(model=model,data_dict=data_dict[key],level=str(key)+".")
     135                else:
     136                    self.read_dict(model=model,data_dict=data_dict[key],level=level+str(key)+".")
     137            else:
     138                if level is None:
     139                    self._default[key] = data_dict[key]
     140                else:
     141                    self._default[level+key] = data_dict[key]
     142                self.initialize(key,data_dict[key],level)
     143
     144        #print "self._data = ",self._data
     145        #print "self._default = ",self._default
     146        #print "read_dict end level = ",level,"\n"
  • coopr.pyomo/trunk/coopr/pyomo/base/block.py

    r5830 r5841  
    401401                apply_parameterized_indexed_rule(
    402402                    self, self._rule, self._model(), block, val )
    403                 for tmp in block.components.itervalues():
    404                     tmp.construct(None)
     403                #for tmp in block.components.itervalues():
     404                #    tmp.construct(None)
    405405                self._data[val] = block
    406406        #self._index=constructed_indices
Note: See TracChangeset for help on using the changeset viewer.