Changeset 3293

Timestamp:

05/03/08 12:18:06 (2 months ago)

Author:

hana

Message:

(hana) EstimationRunner? allows for XML configuration

Location:

trunk/urbansim

Files:

• estimation/estimation_runner.py (modified) (3 diffs)
• tools/start_estimation.py (modified) (2 diffs)

trunk/urbansim/estimation/estimation_runner.py

@@ -22 +22 @@
 class EstimationRunner(Estimator):
      
-    def __init__(self, model, specification_module=None, xml_specification=None, model_group=None,
+    def __init__(self, model, specification_module=None, xml_configuration=None, model_group=None,
                   configuration={}, save_estimation_results=False):
         """
         If 'specification_module' is given, it contains the specification defined as a dictionary in a module.
-        Alternatively, the specification can be passed in an xml format in the 'xml_specification' argument (It is a full path to the xml file). 
+        Alternatively, the specification can be passed in an xml format in the 'xml_configuration' argument (It is a full path to the xml file). 
         If both of those arguments are None, the specification is taken from the cache.
-        'configuration' is an Opus configuration. It can contain an entry 'config_changes_for_estimation' which is a dictionary
+        'configuration' is an Opus configuration. 
+        It can contain an entry 'config_changes_for_estimation' which is a dictionary
         where keys are model names and values are controller changes for that model.
+        If 'configuration' is None, it is taken from 'xml_configuration'.
         If save_estimation_results is True, the estimation results are saved in the oputput configuration 
         (if given in 'configuration') and in the cache.
         """
         self.specification_module = specification_module
-        self.xml_specification = xml_specification
+        self.xml_configuration = xml_configuration
         self.model_group = model_group
         self.estimated_model = model
         
-        config = Configuration(configuration)
+        xml_config = None
+        if self.xml_configuration is not None:
+            xml_config = XMLConfiguration(self.xml_configuration)
+            
+        if configuration is None:
+            if xml_config is None:
+                raise StandardError, "Either dictionary based or XML based configuration must be given."
+            estimation_section = xml_config.get_section('model_manager/estimation')
+            config = estimation_section['estimation_config']
+            xml_config._merge_controllers(config)
+        else:
+            config = Configuration(configuration)
         config_changes = config.get('config_changes_for_estimation', {})
         
         specification_dict=None
-        if xml_specification is not None:
-            specification_dict = XMLConfiguration(xml_specification).get_estimation_specification(model)
+        if xml_config is not None:
+            specification_dict = xml_config.get_estimation_specification(model)
             
         if model_group is None:
             if model in config_changes.keys():
                 config.merge(config_changes[model])
+            else:
+                config['models'] = [{model: ["estimate"]}]
             if specification_module is not None:
                 config = update_controller_by_specification_from_module(
@@ -58 +73 @@
                     config.merge(config_changes[model][model_group])
                 else:
-                    config.merge(config_changes[model])       
+                    config.merge(config_changes[model])
+            else:
+                config['models'] = [{model: {"group_members": [{model_group: ["estimate"]}]}}]
             if (specification_module is not None) or (specification_dict is not None):
                 if '%s_%s' % (model_group, model) in config["models_configuration"].keys():
@@ -79 +96 @@
         """
         specification_dict=None
-        if self.xml_specification is not None:
-            specification_dict = XMLConfiguration(self.xml_specification).get_estimation_specification(self.estimated_model)
+        if self.xml_configuration is not None:
+            specification_dict = XMLConfiguration(self.xml_configuration).get_estimation_specification(self.estimated_model)
         Estimator.reestimate(self, self.specification_module, specification_dict=specification_dict, type=self.model_group, submodels=submodels)
         

trunk/urbansim/tools/start_estimation.py

@@ -26 +26 @@
         self.parser.add_option("-s", "--specification", dest="specification", default = None,
                                action="store", help="Specification module containing model specification in a dictionary format")
-        self.parser.add_option("-x", "--xml-specification", dest="xml_specification", default = None,
-                               action="store", help="Full path to an XML file containing the specification. One of the options -s and -x should be given, otherwise the specification is taken from cache.")
+        self.parser.add_option("-x", "--xml-configuration", dest="xml_configuration", default = None,
+                               action="store", help="Full path to an XML configuration file. One of the options -s and -x should be given, otherwise the specification is taken from cache.")
         self.parser.add_option("-c", "--configuration-path", dest="configuration_path", default=None, 
-                               help="Opus path to Python module defining a configuration.")
+                               help="Opus path to Python module defining a configuration in dictionary format. One of the options -s and -x must be given.")
         self.parser.add_option("--save-results", dest="save_results", default=False, action="store_true", 
                                help="Results will be saved in the output configuration (if given) and in the cache")
@@ -43 +43 @@
     if options.model_name is None:
         raise StandardError, "Model name (argument -m) must be given."
-    if options.configuration_path is None:
-        raise StandardError, "Configuration path (argument -c) must be given."
-    if (options.specification is None) and (options.xml_specification is None):
+    if (options.configuration_path is None) and (options.xml_configuration is None):
+        raise StandardError, "Configuration path (argument -c) or XML configuration (argument -x) must be given."
+    if (options.specification is None) and (options.xml_configuration is None):
         logger.log_warning("No specification given (arguments -s or -x). Specification taken from the cache.")
 
-    config = get_config_from_opus_path(options.configuration_path)
-    estimator = EstimationRunner(model=options.model_name, specification_module=options.specification, xml_specification=options.xml_specification, 
+    if options.configuration_path is None:
+        config = None
+    else:
+        config = get_config_from_opus_path(options.configuration_path)
+    estimator = EstimationRunner(model=options.model_name, specification_module=options.specification, xml_configuration=options.xml_configuration, 
                                  model_group=options.model_group,
-                                 configuration=config, save_estimation_results=options.save_results)
+                                 configuration=config,
+                                 save_estimation_results=options.save_results)
     estimator.estimate()