Changeset 3328

Timestamp:

05/12/08 03:03:33 (2 months ago)

Author:

travis

Message:

(travis) implementing indicator group functionality

Location:

trunk

Files:

• eugene/configs/eugene_gridcell.xml (modified) (2 diffs)
• opus_gui/config/resultsmanager/opusxmlaction_results.py (modified) (2 diffs)
• opus_gui/results/forms/advanced_visualization_form.py (modified) (1 diff)
• opus_gui/results/forms/generate_results_form.py (modified) (4 diffs)
• opus_gui/results/forms/indicator_group_run_form.py (added)
• opus_gui/results/opus_result_generator.py (modified) (10 diffs)
• opus_gui/results/resultManagerBase.py (modified) (2 diffs)

trunk/eugene/configs/eugene_gridcell.xml

@@ -139 +139 @@
   </data_manager>
   <model_manager>
-    <test_model_config type="string">
-    </test_model_config>
+    <test_model_config type="string" />
   </model_manager>
   <scenario_manager>
-    <Eugene_baseline executable="True" setexpanded="True" type="scenario" copyable="True">
+    <Eugene_baseline copyable="True" executable="True" setexpanded="True" type="scenario">
       <parent type="scenario_name">default_scenario</parent>
       <base_year type="integer">1980</base_year>
@@ -309 +308 @@
       </my_indicators>
     </Indicator_libraries>
-    <Indicator_groups setexpanded="True" type="group"/>
-    <Simulation_runs setexpanded="True" type="all_source_data" />
-    <Results setexpanded="True" type="selectable_list" />
+    <Indicator_groups setexpanded="True" type="group">
+      <an_indicator_group type="indicator_group">
+        <industrial_sqft type="indicator_group_member"><visualization_type choices="Map (per indicator per year)|Chart (per indicator, spans years)|Table (per indicator, spans years)|Table (per year, spans indicators)" type="string">Table (per year, spans indicators)</visualization_type>
+          <dataset_name choices="gridcell|zone|faz|large_area|city|county|alldata" type="string">gridcell</dataset_name>
+        </industrial_sqft>
+        <number_of_jobs type="indicator_group_member">
+          <visualization_type choices="Map (per indicator per year)|Chart (per indicator, spans years)|Table (per indicator, spans years)|Table (per year, spans indicators)" type="string">Table (per year, spans indicators)</visualization_type>
+          <dataset_name choices="&apos;gridcell|zone|faz|large_area|city|county|alldata&apos;" type="string">zone</dataset_name>
+        </number_of_jobs>
+      </an_indicator_group>
+    </Indicator_groups>
+    <Simulation_runs setexpanded="True" type="all_source_data">
+
+    </Simulation_runs>
+    <Results setexpanded="True" type="selectable_list">
+
+    </Results>
   </results_manager>
 </opus_project>

trunk/opus_gui/config/resultsmanager/opusxmlaction_results.py

@@ -160 +160 @@
         model = self.currentIndex.model()
         document = model.domDocument
-        name = 'INDICATOR_GROUP_NAME'
+        name = 'untitled_indicator_group'
 
         newNode = model.create_node(document = document, 
@@ -211 +211 @@
                                  child_names = ['available_datasets'])
         
-        datasets = '|'.join(str(available_datasets['available_datasets'])[1:-1].split("','"))
+        datasets = '|'.join(str(available_datasets['available_datasets'])[1:-1].replace("'",'').split(","))
 
         visualizations = [

trunk/opus_gui/results/forms/advanced_visualization_form.py

@@ -280 +280 @@
     def on_pbn_go_released(self):
         # Fire up a new thread and run the model
-        print 'Generate results button pressed'
+        print 'Go button pressed'
 
         # References to the GUI elements for status for this run...

trunk/opus_gui/results/forms/generate_results_form.py

@@ -36 +36 @@
         
         self.available_years_for_simulation_runs = {}
-
+        
         self.result_generator = OpusResultGenerator(
                                     xml_path = self.toolboxStuff.xml_file,
-                                    domDocument = self.domDocument)
+                                    domDocument = self.domDocument, 
+                                    model = self.toolboxStuff.resultsManagerTree.model)
             
         self.result_generator.guiElement = self
@@ -272 +273 @@
                                    years = years)
         
-        self.last_computed_result = {
-            'source_data_name': source_text,
-            'indicator_name': indicator_text,
-            'dataset_name': dataset_name,
-            'years': years                           
-        }
+#        self.last_computed_result = {
+#            'source_data_name': source_text,
+#            'indicator_name': indicator_text,
+#            'dataset_name': dataset_name,
+#            'years': years                           
+#        }
         
         self.runThread = OpusGuiThread(
@@ -307 +308 @@
         print "Results generated met with success = ", success
         
-        self.update_results_xml()
+        #self.update_results_xml()
         
         # Get the final logfile update after model finishes...
@@ -313 +314 @@
         self.pbn_generate_results.setEnabled(True)
     
-    def update_results_xml(self):
-        print "update results"
-        xml_tree = self.toolboxStuff.resultsManagerTree
-        model = xml_tree.model
-        document = self.domDocument
-
-        name = '%s.%s.%s'%(self.last_computed_result['indicator_name'], 
-            self.last_computed_result['dataset_name'], 
-            self.last_computed_result['source_data_name'])
-        
-        newNode = model.create_node(document = document, 
-                                    name = name, 
-                                    type = 'indicator_result', 
-                                    value = '')
-        source_data_node = model.create_node(document = document, 
-                                    name = 'source_data', 
-                                    type = 'string', 
-                                    value = self.last_computed_result['source_data_name'])
-        indicator_node = model.create_node(document = document, 
-                                    name = 'indicator_name', 
-                                    type = 'string', 
-                                    value = self.last_computed_result['indicator_name'])        
-        dataset_node = model.create_node(document = document, 
-                                    name = 'dataset_name', 
-                                    type = 'string', 
-                                    value = self.last_computed_result['dataset_name'])
-        year_node = model.create_node(document = document, 
-                                    name = 'available_years', 
-                                    type = 'string', 
-                                    value = ', '.join([repr(year) for year in self.last_computed_result['years']]))                
-        parent = model.index(0,0,QModelIndex()).parent()
-        index = model.findElementIndexByName("Results", parent)[0]
-        if index.isValid():
-            model.insertRow(0,
-                            index,
-                            newNode)
-        else:
-            print "No valid node was found..."
-        
-        child_index = model.findElementIndexByName(name, parent)[0]
-        if child_index.isValid():
-            for node in [dataset_node, indicator_node, source_data_node, year_node]:
-                model.insertRow(0,
-                                child_index,
-                                node)
-        else:
-            print "No valid node was found..."
-        
-        model.emit(SIGNAL("layoutChanged()"))
+#    def update_results_xml(self):
+#        print "update results"
+#        xml_tree = self.toolboxStuff.resultsManagerTree
+#        model = xml_tree.model
+#        document = self.domDocument
+#
+#        name = '%s.%s.%s'%(self.last_computed_result['indicator_name'], 
+#            self.last_computed_result['dataset_name'], 
+#            self.last_computed_result['source_data_name'])
+#        
+#        newNode = model.create_node(document = document, 
+#                                    name = name, 
+#                                    type = 'indicator_result', 
+#                                    value = '')
+#        source_data_node = model.create_node(document = document, 
+#                                    name = 'source_data', 
+#                                    type = 'string', 
+#                                    value = self.last_computed_result['source_data_name'])
+#        indicator_node = model.create_node(document = document, 
+#                                    name = 'indicator_name', 
+#                                    type = 'string', 
+#                                    value = self.last_computed_result['indicator_name'])        
+#        dataset_node = model.create_node(document = document, 
+#                                    name = 'dataset_name', 
+#                                    type = 'string', 
+#                                    value = self.last_computed_result['dataset_name'])
+#        year_node = model.create_node(document = document, 
+#                                    name = 'available_years', 
+#                                    type = 'string', 
+#                                    value = ', '.join([repr(year) for year in self.last_computed_result['years']]))                
+#        parent = model.index(0,0,QModelIndex()).parent()
+#        index = model.findElementIndexByName("Results", parent)[0]
+#        if index.isValid():
+#            model.insertRow(0,
+#                            index,
+#                            newNode)
+#        else:
+#            print "No valid node was found..."
+#        
+#        child_index = model.findElementIndexByName(name, parent)[0]
+#        if child_index.isValid():
+#            for node in [dataset_node, indicator_node, source_data_node, year_node]:
+#                model.insertRow(0,
+#                                child_index,
+#                                node)
+#        else:
+#            print "No valid node was found..."
+#        
+#        model.emit(SIGNAL("layoutChanged()"))
 
     def runErrorFromThread(self,errorMessage):

trunk/opus_gui/results/opus_result_generator.py

@@ -74 +74 @@
 
 
-
+class OpusIndicatorGroupProcessor(object):
+    def __init__(self, 
+                 xml_path, 
+                 domDocument,
+                 model,
+                 kwargs = None):
+          
+        self.generator = OpusResultGenerator(
+           xml_path = xml_path,
+           domDocument = domDocument,
+           model = model                                            
+        )
+          
+        self.visualizer = OpusResultVisualizer(
+           xml_path = xml_path,
+           domDocument = domDocument,
+           indicator_type = None,
+           indicators = None,
+           kwargs = kwargs                     
+        )
+        self.finishedCallback = None
+        self.errorCallback = None
+            
+    def set_data(self,                  
+                 indicator_defs, 
+                 source_data_name,
+                 years):
+        
+        self.indicator_defs = indicator_defs
+        self.years = years
+        self.source_data_name = source_data_name        
+        
+    def run(self):
+        succeeded = False
+        
+        try:
+            self.visualizations = []
+            for (visualization_type, dataset_name), indicators in self.indicator_defs.items():
+                indicator_results = []
+                for indicator_name in indicators:
+                    try:
+                        self.generator.set_data(self.source_data_name, 
+                                                indicator_name, 
+                                                dataset_name, 
+                                                self.years)
+                        self.generator.run()
+                        indicator = {'indicator_name':indicator_name,#self.generator.last_added_indicator_result_name,
+                                     'dataset_name':dataset_name,
+                                     'source_data_name':self.source_data_name,
+                                     'years':self.years}
+                        indicator_results.append(indicator)
+                        
+                    except:
+                        print 'could not generate indicator %s'%indicator_name
+                self.visualizer.indicator_type = visualization_type
+                self.visualizer.indicators = indicator_results
+                try:
+                    import pydevd;pydevd.settrace()
+                except:
+                    pass
+                self.visualizer.run()
+                self.visualizations.append((visualization_type, self.visualizer.get_visualizations()))
+            
+            succeeded = True
+        except:
+            succeeded = False
+            errorInfo = formatExceptionInfo()
+            errorString = "Unexpected Error From Model :: " + str(errorInfo)
+            print errorInfo
+            self.errorCallback(errorString)
+
+        self.finishedCallback(succeeded)
+    
+    def get_visualizations(self): 
+        return self.visualizations
+    
 class OpusResultVisualizer(object):
     def __init__(self, 
@@ -101 +176 @@
             try:
                 # find the directory containing the eugene xml configurations
-                fileNameInfo = QFileInfo(self.xml_path)
-                fileNameAbsolute = fileNameInfo.absoluteFilePath().trimmed()
-                self._visualize(configuration_path = fileNameAbsolute)
+                self._visualize()
                 succeeded = True
             except:
@@ -110 +183 @@
                 errorString = "Unexpected Error From Model :: " + str(errorInfo)
                 print errorInfo
-                self.errorCallback(errorString)
-
-            self.finishedCallback(succeeded)
+                if self.errorCallback is not None:
+                    self.errorCallback(errorString)
+            if self.finishedCallback is not None:
+                self.finishedCallback(succeeded)
         else:
             pass
@@ -118 +192 @@
 
         
-    def _visualize(self, configuration_path):
+    def _visualize(self):
         indicators_to_visualize = {}
         interface = IndicatorFrameworkInterface(domDocument = self.domDocument)
@@ -207 +281 @@
 class OpusResultGenerator(object):
     
-    def __init__(self, xml_path, domDocument):
+    def __init__(self, xml_path, domDocument, model):
         self.xml_path = xml_path
         self.finishedCallback = None
@@ -215 +289 @@
         self.firstRead = True
         self.domDocument = domDocument
+        self.model = model
     
     def set_data(self,
@@ -231 +306 @@
             succeeded = False
             try:
-                # find the directory containing the eugene xml configurations
-                fileNameInfo = QFileInfo(self.xml_path)
-                fileNameAbsolute = fileNameInfo.absoluteFilePath().trimmed()
-                configuration_path = fileNameAbsolute
                 try:
                     import pydevd;pydevd.settrace()
@@ -240 +311 @@
                     pass
                 
-                self._generate_results(configuration_path = configuration_path)
+                self._generate_results()
                 succeeded = True
             except Exception, e:
@@ -255 +326 @@
                 )
                 print errorString
-                self.errorCallback(errorString)
-
-            self.finishedCallback(succeeded)
+                if self.errorCallback is not None:
+                    self.errorCallback(errorString)
+            if self.finishedCallback is not None:
+                self.finishedCallback(succeeded)
         else:
             pass
 
-    def _generate_results(self, configuration_path):
+    def _generate_results(self):
 #        try:
 #            import pydevd;pydevd.settrace()
@@ -281 +353 @@
         computed_indicator = maker.create(indicator = indicator, 
                                           source_data = source_data)
+        self.update_results_xml()
+
+    def update_results_xml(self):
+        print "update results"
+        model = self.model
+        document = self.domDocument
+        
+        name = '%s.%s.%s'%(self.indicator_name, 
+            self.dataset_name, 
+            self.source_data_name)
+        
+        self.last_added_indicator_result_name = name
+        
+        newNode = model.create_node(document = document, 
+                                    name = name, 
+                                    type = 'indicator_result', 
+                                    value = '')
+        source_data_node = model.create_node(document = document, 
+                                    name = 'source_data', 
+                                    type = 'string', 
+                                    value = self.source_data_name)
+        indicator_node = model.create_node(document = document, 
+                                    name = 'indicator_name', 
+                                    type = 'string', 
+                                    value = self.indicator_name)        
+        dataset_node = model.create_node(document = document, 
+                                    name = 'dataset_name', 
+                                    type = 'string', 
+                                    value = self.dataset_name)
+        year_node = model.create_node(document = document, 
+                                    name = 'available_years', 
+                                    type = 'string', 
+                                    value = ', '.join([repr(year) for year in self.years]))                
+        parent = model.index(0,0,QModelIndex()).parent()
+        index = model.findElementIndexByName("Results", parent)[0]
+        if index.isValid():
+            model.insertRow(0,
+                            index,
+                            newNode)
+        else:
+            print "No valid node was found..."
+        
+        child_index = model.findElementIndexByName(name, parent)[0]
+        if child_index.isValid():
+            for node in [dataset_node, indicator_node, source_data_node, year_node]:
+                model.insertRow(0,
+                                child_index,
+                                node)
+        else:
+            print "No valid node was found..."
+        
+        model.emit(SIGNAL("layoutChanged()"))
                 
     def _get_current_log(self, key):

trunk/opus_gui/results/resultManagerBase.py

@@ -255 +255 @@
         self.visualizer = None
 
-    def addViewImageIndicator(self, visualization):
+    def addViewImageIndicator(self, visualization, indicator_type = None):
         new_form = ViewImageForm(parent = self.parent,
                                  visualization = visualization)
@@ -261 +261 @@
         self.updateGuiElements()
 
-    def addViewTableIndicator(self, visualization):
+    def addViewTableIndicator(self, visualization, indicator_type):
         new_form = ViewTableForm(parent = self.parent,
                                  visualization = visualization)
-        if self.indicator_type != 'arcgis_map':
+        if indicator_type != 'arcgis_map':
             self.guiElements.insert(0, new_form)
             self.updateGuiElements()