示例#1
0
 def run(self):
     # Call the tool, passing in the callbacks
     #
     # There are really two ways to call the tool
     # 1) Call the tool as a system command
     # 2) Call the run() function of the tool
     #
     # The first option has the benifit of the standard __main__ syntax,
     # but the second option allows for use of the callbacks.
     #
     # The prefered method for opus tools is the second option
     #
     # EXAMPLE
     #
     try:
         importString = "from %s import opusRun" % (self.toolInclude)
         #print importString
         exec(importString)
         self.params = self.buildparams()
         if self.startingCallback != None:
             self.startingCallback()
         success = opusRun(self.progressCallback, self.logCallback,
                           self.toolVars)  #@UndefinedVariable
         if self.finishedCallback != None:
             self.progressCallback(100)
             self.finishedCallback(success)
     except ImportError, e:
         print "ImportError: %s" % formatExceptionInfo()
         success = False
         self.logCallback("Error importing %s: %s" %
                          (self.toolInclude, formatExceptionInfo()))
         self.finishedCallback(success)
示例#2
0
 def run(self):
     # Call the tool, passing in the callbacks
     #
     # There are really two ways to call the tool
     # 1) Call the tool as a system command
     # 2) Call the run() function of the tool
     #
     # The first option has the benifit of the standard __main__ syntax,
     # but the second option allows for use of the callbacks.
     #
     # The prefered method for opus tools is the second option
     #
     # EXAMPLE
     #
     try:
         importString = "from %s import opusRun" % (self.toolInclude)
         #print importString
         exec(importString)
         self.params = self.buildparams()
         if self.startingCallback != None:
             self.startingCallback()
         success = opusRun(self.progressCallback,self.logCallback,self.toolVars) #@UndefinedVariable
         if self.finishedCallback != None:
             self.progressCallback(100)
             self.finishedCallback(success)
     except ImportError, e:
         print "ImportError: %s" % formatExceptionInfo()
         success = False
         self.logCallback("Error importing %s: %s" % (self.toolInclude, formatExceptionInfo()) )
         self.finishedCallback(success)
示例#3
0
    def saveProjectAs(self):
        ''' Save the project configuration under a different name '''
        try:
            # get the location for the new config file on disk
            start_dir = paths.OPUS_PROJECT_CONFIGS_PATH
            configDialog = QFileDialog()
            filter_str = QString("*.xml")
            fd = configDialog.getSaveFileName(self, QString("Save As..."),
                                              QString(start_dir), filter_str)
            # Check for cancel
            if not fd:
                return

            filename = QString(fd)
            # append xml extension if no extension was given
            if not filename.endsWith('.xml') and len(filename.split('.')) == 1:
                filename = filename + '.xml'

            if not self.saveProject(filename):
                return

            # hack: open the project right after save to properly change the
            # 'active project' related parameters
            self.openProject(filename)

        except:
            errorMessage = formatExceptionInfo(custom_message = \
                                               'Unexpected error saving config')
            QMessageBox.warning(self, 'Warning', errorMessage)
示例#4
0
    def execToolFile(self):
        '''
        Show a dialog box that lets the user configure and execute a
        tool.
        '''
        assert self.has_selected_item()

        tool_lib_node = get_tool_library_node(self.project)
        params = {'tool_path': get_path_to_tool_modules(self.project)}

        tool_node = self.selected_item().node

        try:
            module_name = tool_node.find('class_module').text
            import_path = params['tool_path'] + '.' + module_name
            importString = "from %s import opusRun" % (import_path)
            exec(importString)
        except Exception, e:
            print e
            MessageBox.error(mainwindow = self.view,
                text = 'Invalid module name',
                detailed_text = ('This tool points to a module named "%s", ' % import_path + \
                                 'but there is no module with that name, or module returned import error: %s. ' \
                                 % formatExceptionInfo()
                                 ))
            return
    def execBatch(self):
        ''' Present a dialog to execute a set of tool configurations '''
        assert self.has_selected_item()
        # Node representing the set to execute
        tool_set_node = self.selected_item().node

        # map tool config nodes in set -> name of the hooked node
        tool_config_to_tool_name = {}
        tool_config_nodes = tool_set_node[:]
        for tool_config_node in tool_config_nodes:
            hook_node = tool_config_node.find('tool_hook')
            hooked_tool_name = str(hook_node.text or '').strip()
            hooked_tool_node = get_tool_node_by_name(self.project, hooked_tool_name)
            module_name = hooked_tool_node.find('class_module').text
            
            try:
                module_name = hooked_tool_node.find('class_module').text
                tool_path = get_path_to_tool_modules(self.project)
                import_path = tool_path + '.' + module_name
                importString = "from %s import opusRun" % (import_path)
                exec(importString)
                tool_config_to_tool_name[tool_config_node] = import_path
            except Exception, e:
                MessageBox.error(mainwindow = self.view,
                    text = 'Invalid module name',
                    detailed_text = ('This tool points to a module named "%s", ' % import_path + \
                                     'but there is no module with that name, or module returned import error: %s. ' \
                                     % formatExceptionInfo() 
                                     ))
                return
    def execToolFile(self):
        '''
        Show a dialog box that lets the user configure and execute a
        tool.
        '''
        assert self.has_selected_item()

        tool_lib_node = get_tool_library_node(self.project)
        params = {'tool_path': get_path_to_tool_modules(self.project)}

        tool_node = self.selected_item().node

        try:
            module_name = tool_node.find('class_module').text
            import_path = params['tool_path'] + '.' + module_name
            importString = "from %s import opusRun" % (import_path)
            exec(importString)
        except Exception, e:
            print e
            MessageBox.error(mainwindow = self.view,
                text = 'Invalid module name',
                detailed_text = ('This tool points to a module named "%s", ' % import_path + \
                                 'but there is no module with that name, or module returned import error: %s. ' \
                                 % formatExceptionInfo() 
                                 ))
            return
示例#7
0
    def execBatch(self):
        ''' Present a dialog to execute a set of tool configurations '''
        assert self.has_selected_item()
        # Node representing the set to execute
        tool_set_node = self.selected_item().node

        # map tool config nodes in set -> name of the hooked node
        tool_config_to_tool_name = {}
        tool_config_nodes = tool_set_node[:]
        for tool_config_node in tool_config_nodes:
            hook_node = tool_config_node.find('tool_hook')
            hooked_tool_name = str(hook_node.text or '').strip()
            hooked_tool_node = get_tool_node_by_name(self.project,
                                                     hooked_tool_name)
            module_name = hooked_tool_node.find('class_module').text

            try:
                module_name = hooked_tool_node.find('class_module').text
                tool_path = get_path_to_tool_modules(self.project)
                import_path = tool_path + '.' + module_name
                importString = "from %s import opusRun" % (import_path)
                exec(importString)
                tool_config_to_tool_name[tool_config_node] = import_path
            except Exception, e:
                MessageBox.error(mainwindow = self.view,
                    text = 'Invalid module name',
                    detailed_text = ('This tool points to a module named "%s", ' % import_path + \
                                     'but there is no module with that name, or module returned import error: %s. ' \
                                     % formatExceptionInfo()
                                     ))
                return
示例#8
0
    def saveProjectAs(self):
        ''' Save the project configuration under a different name '''
        try:
            # get the location for the new config file on disk
            start_dir = paths.OPUS_PROJECT_CONFIGS_PATH
            configDialog = QFileDialog()
            filter_str = QString("*.xml")
            fd = configDialog.getSaveFileName(self,QString("Save As..."),
                                              QString(start_dir), filter_str)
            # Check for cancel
            if not fd:
                return

            filename = QString(fd)
            # append xml extension if no extension was given
            if not filename.endsWith('.xml') and len(filename.split('.')) == 1:
                filename = filename + '.xml'

            if not self.saveProject(filename):
                return

            # hack: open the project right after save to properly change the
            # 'active project' related parameters
            self.openProject(filename)

        except:
            errorMessage = formatExceptionInfo(custom_message = \
                                               'Unexpected error saving config')
            QMessageBox.warning(self, 'Warning', errorMessage)
    def _get_viz_spec(self):
        viz_type = self.cboVizType.currentText()
        translation = self._get_output_types(viz_type)
        dataset_name = self.dataset_name
        output_type = QString(translation[str(self.cboOutputType.currentText())])
        indicators = QString(str(self._get_column_values(column = 0)))

        vals = {
                'indicators': indicators,
                'output_type': output_type,
                'dataset_name': dataset_name,
                'visualization_type': QString(self._get_type_mapper()[str(viz_type)])
        }

        if output_type == 'mapnik_map' or output_type == 'mapnik_animated_map':
            vals['mapnik_bucket_labels'] = self.mapnik_options['mapnik_bucket_labels']
            vals['mapnik_bucket_colors'] = self.mapnik_options['mapnik_bucket_colors']
            vals['mapnik_bucket_ranges'] = self.mapnik_options['mapnik_bucket_ranges']
            vals['mapnik_resolution'] = self.mapnik_options['mapnik_resolution']
            vals['mapnik_page_dims'] = self.mapnik_options['mapnik_page_dims']
            vals['mapnik_map_lower_left'] = self.mapnik_options['mapnik_map_lower_left']
            vals['mapnik_map_upper_right'] = self.mapnik_options['mapnik_map_upper_right']
            vals['mapnik_legend_lower_left'] = self.mapnik_options['mapnik_legend_lower_left']
            vals['mapnik_legend_upper_right'] = self.mapnik_options['mapnik_legend_upper_right']


        elif output_type == 'fixed_field':
            try:
                fixed_field_params = QString(str(self._get_column_values(column = 1)))
            except:
                errorInfo = formatExceptionInfo()
                logger.log_error(errorInfo)
                MessageBox.error(mainwindow = self,
                                text = 'Could not get fixed field parameters for all columns',
                                detailed_text = '')
                return None

            vals['fixed_field_specification'] = fixed_field_params
            vals['id_format'] = self.leOption1.text()
        elif output_type == 'sql':
            vals['database_name'] = self.leOption1.text()
        elif output_type == 'esri':
            vals['storage_location'] = self.leOption1.text()
        elif output_type in ('tab', 'xls'):
            if self.rbSingleTable.isChecked():
                output_style = Table.ALL
            elif self.rbTablePerIndicator.isChecked():
                output_style = Table.PER_ATTRIBUTE
            elif self.rbTablePerYear.isChecked():
                output_style = Table.PER_YEAR
            vals['output_style'] = QString(str(output_style))
            if self.appendTypeCheckBox.isChecked():
                vals['append_col_type'] = True
            else:
                vals['append_col_type'] = False
            if output_type == 'xls':
                vals['storage_location'] = self.leOption1.text()

        return vals
示例#10
0
    def on_buttonBox_accepted(self):
        path = str(self.lePath.text())
        if not os.path.exists(path):
            msg = 'Cannot import, %s does not exist' % path
            logger.log_warning(msg)
            MessageBox.warning(mainwindow=self, text=msg, detailed_text='')
        else:
            cache_directory = path
            years = []

            for dir in os.listdir(cache_directory):
                if len(dir) == 4 and dir.isdigit():
                    years.append(int(dir))
            if years == []:
                msg = 'Cannot import, %s has no run data' % path
                logger.log_warning(msg)
                MessageBox.warning(mainwindow=self, text=msg, detailed_text='')

            else:
                start_year = min(years)
                end_year = max(years)
                project_name = os.environ['OPUSPROJECTNAME']
                run_name = os.path.basename(path)

                server_config = ServicesDatabaseConfiguration()
                run_manager = RunManager(server_config)

                run_id = run_manager._get_new_run_id()
                resources = {
                    'cache_directory': cache_directory,
                    'description': '',
                    'years': (start_year, end_year),
                    'project_name': project_name
                }

                try:
                    run_manager.add_row_to_history(run_id=run_id,
                                                   resources=resources,
                                                   status='done',
                                                   run_name=run_name)
                    update_available_runs(self.project)
                    logger.log_status(
                        'Added run %s of project %s to run_activity table' %
                        (run_name, project_name))
                except:
                    errorInfo = formatExceptionInfo()
                    logger.log_error(errorInfo)
                    MessageBox.error(
                        mainwindow=self,
                        text=
                        'Could not add run %s of project %s to run_activity table'
                        % (run_name, project_name),
                        detailed_text=errorInfo)
        self.close()
    def on_buttonBox_accepted(self):
        path = str(self.lePath.text())
        if not os.path.exists(path):
            msg = 'Cannot import, %s does not exist' % path
            logger.log_warning(msg)
            MessageBox.warning(mainwindow = self,
                            text = msg,
                            detailed_text = '')
        else:
            cache_directory = path
            years = []

            for dir in os.listdir(cache_directory):
                if len(dir) == 4 and dir.isdigit():
                    years.append(int(dir))
            if years == []:
                msg = 'Cannot import, %s has no run data'%path
                logger.log_warning(msg)
                MessageBox.warning(mainwindow = self,
                                text = msg,
                                detailed_text = '')

            else:
                start_year = min(years)
                end_year = max(years)
                project_name = os.environ['OPUSPROJECTNAME']
                run_name = os.path.basename(path)

                server_config = ServicesDatabaseConfiguration()
                run_manager = RunManager(server_config)

                run_id = run_manager._get_new_run_id()
                resources = {
                     'cache_directory': cache_directory,
                     'description': '',
                     'years': (start_year, end_year),
                     'project_name': project_name
                }

                try:
                    run_manager.add_row_to_history(run_id = run_id,
                                                   resources = resources,
                                                   status = 'done',
                                                   run_name = run_name)
                    update_available_runs(self.project)
                    logger.log_status('Added run %s of project %s to run_activity table'%(run_name, project_name))
                except:
                    errorInfo = formatExceptionInfo()
                    logger.log_error(errorInfo)
                    MessageBox.error(mainwindow = self,
                                    text = 'Could not add run %s of project %s to run_activity table'%(run_name, project_name),
                                    detailed_text = errorInfo)
        self.close()
示例#12
0
    def run(self, args = {}):
        succeeded = False

        if self.errorCallback is not None:
            self.generator.errorCallback = self.errorCallback
            self.visualizer.errorCallback = self.errorCallback

#        try:
#            import pydevd;pydevd.settrace()
#        except:
#            pass

        try:
            self.visualizations = []
            
            for (visualization_type, dataset_name, params) in self.visualization_configurations:                
                indicator_results = []
                indicators = self._get_indicators(params)
                for indicator_name in indicators:
                    try:
                        self.generator.set_data(self.source_data_name,
                                                indicator_name,
                                                dataset_name,
                                                self.years,
                                                cache_directory = self.cache_directory)
                        self.generator.run()
                        indicator = {'indicator_name':indicator_name,
                                     'dataset_name':dataset_name,
                                     'source_data_name':self.source_data_name,
                                     'years':self.years}
                        indicator_results.append(indicator)

                    except:
                        logger.log_warning('could not generate indicator %s'%indicator_name)
                self.visualizer.indicator_type = visualization_type
                self.visualizer.indicators = indicator_results

                viz_args = self._get_viz_args(visualization_type, params, indicators)

                self.visualizer.run(args = viz_args, cache_directory = self.cache_directory)
                if self.visualizer.get_visualizations() != []:
                    self.visualizations.append((visualization_type, self.visualizer.get_visualizations()))

            succeeded = True
        except:
            succeeded = False
            errorInfo = formatExceptionInfo(custom_message = 'Unexpected error in the batch processor')
            self.errorCallback(errorInfo)

        if self.finishedCallback: self.finishedCallback(succeeded)
    def run(self, args, cache_directory = None):
        succeeded = False
        try:
            # find the directory containing the eugene xml configurations
            not_visualized = self._visualize(args, cache_directory = cache_directory)
            succeeded = True
        except:
            succeeded = False
            errorInfo = formatExceptionInfo(custom_message = 'Unexpected error in the results visualizer')

            if self.errorCallback is not None:
                self.errorCallback(errorInfo)

        if self.finishedCallback is not None:
            self.finishedCallback(succeeded)
示例#14
0
    def run(self, args={}, raise_exception=False):

        succeeded = False
        try:
            #                try:
            #                    import pydevd;pydevd.settrace()
            #                except:
            #                    pass

            self._generate_results()
            succeeded = True
        except Exception, e:
            succeeded = False
            errorinfo = formatExceptionInfo(custom_message="Unexpected error in the result generator")
            self.errorCallback(errorinfo)
            if raise_exception:
                raise e
    def run(self, args={}, raise_exception=False):

        succeeded = False
        try:
            #                try:
            #                    import pydevd;pydevd.settrace()
            #                except:
            #                    pass

            self._generate_results()
            succeeded = True
        except Exception, e:
            succeeded = False
            errorinfo = formatExceptionInfo(
                custom_message='Unexpected error in the result generator')
            self.errorCallback(errorinfo)
            if raise_exception:
                raise e
示例#16
0
    def run(self):
        # Start the estimation. This code adapted from urbansim/tools/start_estimation.py
        # statusdir is a temporary directory into which to write a status file
        # regarding the progress of the simulation - the progress bar reads this file
        statusfile = None
        succeeded = False
        try:
            # get the configuration for estimations
            estimation_section = self.xml_config.get_section('model_manager')
            estimation_config = estimation_section['estimation_config']
            self.config = estimation_config
            # TODO: put this option into post run dialog
            save_results = estimation_config['save_estimation_results']

            # If we've paused the estimation, wait 10 seconds, and see if we are unpaused.  If we've cancelled,
            # exit the loop.  Note that this is a fairly coarse level of pause/resume/stop (at the level of
            # estimating an entire model, rather than a bit of a model).
            while self.paused and not self.cancelled:
                time.sleep(10)
            if not self.cancelled:
                self.er = EstimationRunner(
                    model=self.model_name,
                    specification_module=None,
                    xml_configuration=self.xml_config,
                    model_group=self.model_group,
                    configuration=None,
                    save_estimation_results=save_results)
                self.running = True
                self.er.estimate()
                self.running = False
                succeeded = True
        except:
            succeeded = False
            self.running = False
            errorInfo = formatExceptionInfo(
                custom_message='Unexpected Error From Estimation')
            self.errorCallback(errorInfo)
        if statusfile is not None:
            os.remove(statusfile)
        del self.er
        gc.collect()
        self.finishedCallback(succeeded)
示例#17
0
    def run(self):
        # Start the estimation. This code adapted from urbansim/tools/start_estimation.py
        # statusdir is a temporary directory into which to write a status file
        # regarding the progress of the simulation - the progress bar reads this file
        statusfile = None
        succeeded = False
        try:
            # get the configuration for estimations
            estimation_section = self.xml_config.get_section('model_manager')
            estimation_config = estimation_section['estimation_config']
            self.config = estimation_config
            # TODO: put this option into post run dialog
            save_results = estimation_config['save_estimation_results']

            # If we've paused the estimation, wait 10 seconds, and see if we are unpaused.  If we've cancelled,
            # exit the loop.  Note that this is a fairly coarse level of pause/resume/stop (at the level of
            # estimating an entire model, rather than a bit of a model).
            while self.paused and not self.cancelled:
                time.sleep(10)
            if not self.cancelled:
                self.er = EstimationRunner(model = self.model_name,
                                           specification_module = None,
                                           xml_configuration = self.xml_config,
                                           model_group = self.model_group,
                                           configuration = None,
                                           save_estimation_results=save_results)
                self.running = True
                self.er.estimate()
                self.running = False
                succeeded = True
        except:
            succeeded = False
            self.running = False
            errorInfo = formatExceptionInfo(custom_message = 'Unexpected Error From Estimation')
            self.errorCallback(errorInfo)
        if statusfile is not None:
            os.remove(statusfile)
        del self.er
        self.er = None
        gc.collect()
        self.finishedCallback(succeeded)
示例#18
0
    def _get_viz_spec(self):
        viz_type = self.cboVizType.currentText()
        translation = self._get_output_types(viz_type)
        dataset_name = self.dataset_name
        output_type = QString(translation[str(
            self.cboOutputType.currentText())])
        indicators = QString(str(self._get_column_values(column=0)))

        vals = {
            'indicators': indicators,
            'output_type': output_type,
            'dataset_name': dataset_name,
            'visualization_type':
            QString(self._get_type_mapper()[str(viz_type)])
        }

        if output_type == 'mapnik_map' or output_type == 'mapnik_animated_map':
            vals['mapnik_bucket_labels'] = self.mapnik_options[
                'mapnik_bucket_labels']
            vals['mapnik_bucket_colors'] = self.mapnik_options[
                'mapnik_bucket_colors']
            vals['mapnik_bucket_ranges'] = self.mapnik_options[
                'mapnik_bucket_ranges']
            vals['mapnik_resolution'] = self.mapnik_options[
                'mapnik_resolution']
            vals['mapnik_page_dims'] = self.mapnik_options['mapnik_page_dims']
            vals['mapnik_map_lower_left'] = self.mapnik_options[
                'mapnik_map_lower_left']
            vals['mapnik_map_upper_right'] = self.mapnik_options[
                'mapnik_map_upper_right']
            vals['mapnik_legend_lower_left'] = self.mapnik_options[
                'mapnik_legend_lower_left']
            vals['mapnik_legend_upper_right'] = self.mapnik_options[
                'mapnik_legend_upper_right']

        elif output_type == 'fixed_field':
            try:
                fixed_field_params = QString(
                    str(self._get_column_values(column=1)))
            except:
                errorInfo = formatExceptionInfo()
                logger.log_error(errorInfo)
                MessageBox.error(
                    mainwindow=self,
                    text='Could not get fixed field parameters for all columns',
                    detailed_text='')
                return None

            vals['fixed_field_specification'] = fixed_field_params
            vals['id_format'] = self.leOption1.text()
        elif output_type == 'sql':
            vals['database_name'] = self.leOption1.text()
        elif output_type == 'esri':
            vals['storage_location'] = self.leOption1.text()
        elif output_type == 'tab':
            if self.rbSingleTable.isChecked():
                output_style = Table.ALL
            elif self.rbTablePerIndicator.isChecked():
                output_style = Table.PER_ATTRIBUTE
            elif self.rbTablePerYear.isChecked():
                output_style = Table.PER_YEAR

            vals['output_style'] = QString(str(output_style))

        return vals
示例#19
0
    def run(self):
        # Run the Eugene model using the XML version of the Eugene configuration.
        # This code adapted from opus_core/tools/start_run.py
        # statusdir is a temporary directory into which to write a status file
        # regarding the progress of the simulation - the progress bar reads this file
        statusdir = None
        succeeded = False
        run_id = None

        try:
            config = self.xml_config.get_run_configuration(str(self.scenariotorun))
            # self.xmltreeobject.toolboxbase.opus_core_xml_configuration.get_run_configuration(str(self.scenariotorun))

            cache_directory_root = config['creating_baseyear_cache_configuration'].cache_directory_root
            run_name = self.get_run_name(config = config, run_name = self.run_name)
            config['cache_directory'] = os.path.join(cache_directory_root, run_name)

            #insert_auto_generated_cache_directory_if_needed(config)
            (self.start_year, self.end_year) = config['years']

            run_manager = get_run_manager()

            run_manager.setup_new_run(cache_directory = config['cache_directory'],
                                      configuration = config)
            
            statusdir = run_manager.get_current_cache_directory()
            self.statusfile = os.path.join(statusdir, 'status.txt')
            self.currentLogfileYear = self.start_year
            self.currentLogfileKey = 0
            self.config = config
            config['status_file_for_gui'] = self.statusfile
            self.commandfile = os.path.join(statusdir, 'command.txt')
            config['command_file_for_gui'] = self.commandfile

            # To test delay in writing the first log file entry...
            # time.sleep(5)
            self.running = True
            self.run_name = run_name
            self.run_manager = run_manager
            run_id = run_manager.run_id
            self.startedCallback(run_id = run_id, 
                                 run_name = run_name, 
                                 scenario_name = self.scenariotorun, 
                                 run_resources = config,
                                 status = 'running')
            run_manager.run_run(config, run_name=run_name, 
                                scenario_name=self.scenariotorun)
            self.running = False
            succeeded = True
            
        except SimulationRunError:
            self.running = False
            succeeded = False
        except:
            self.running = False
            succeeded = False
            errorInfo = formatExceptionInfo(custom_message = 'Unexpected Error From Model')
            self.errorCallback(errorInfo)
        if self.statusfile is not None:
            gc.collect()
            # adding try/except, windows sometimes has a lock on this file
            # when it does, os.remove will cause the simulation to appear
            # as if it has crashed, when in fact it simply could not delete
            # status.txt
            try:
                os.remove(self.statusfile)
            except:
                pass
        self.finishedCallback(succeeded, run_name = run_name)
示例#20
0
    def run(self):
        # Run the Eugene model using the XML version of the Eugene configuration.
        # This code adapted from opus_core/tools/start_run.py
        # statusdir is a temporary directory into which to write a status file
        # regarding the progress of the simulation - the progress bar reads this file
        statusdir = None
        succeeded = False
        run_id = None

        try:
            config = self.xml_config.get_run_configuration(str(
                self.modeltorun))
            # self.xmltreeobject.toolboxbase.opus_core_xml_configuration.get_run_configuration(str(self.modeltorun))

            cache_directory_root = config[
                'creating_baseyear_cache_configuration'].cache_directory_root
            run_name = self.get_run_name(config=config, run_name=self.run_name)
            config['cache_directory'] = os.path.join(cache_directory_root,
                                                     run_name)

            #insert_auto_generated_cache_directory_if_needed(config)
            (self.start_year, self.end_year) = config['years']

            run_manager = get_run_manager()

            run_manager.setup_new_run(
                cache_directory=config['cache_directory'],
                configuration=config)

            statusdir = run_manager.get_current_cache_directory()
            self.statusfile = os.path.join(statusdir, 'status.txt')
            self.currentLogfileYear = self.start_year
            self.currentLogfileKey = 0
            self.config = config
            config['status_file_for_gui'] = self.statusfile
            self.commandfile = os.path.join(statusdir, 'command.txt')
            config['command_file_for_gui'] = self.commandfile

            # To test delay in writing the first log file entry...
            # time.sleep(5)
            self.running = True
            self.run_name = run_name
            self.run_manager = run_manager
            self.startedCallback(run_id=run_id,
                                 run_name=run_name,
                                 scenario_name=self.modeltorun,
                                 run_resources=config)
            run_id = run_manager.run_run(config, run_name=run_name)
            self.running = False
            succeeded = True
        except SimulationRunError:
            self.running = False
            succeeded = False
        except:
            self.running = False
            succeeded = False
            errorInfo = formatExceptionInfo(
                custom_message='Unexpected Error From Model')
            self.errorCallback(errorInfo)
        if self.statusfile is not None:
            gc.collect()
            # adding try/except, windows sometimes has a lock on this file
            # when it does, os.remove will cause the simulation to appear
            # as if it has crashed, when in fact it simply could not delete
            # status.txt
            try:
                os.remove(self.statusfile)
            except:
                pass
        self.finishedCallback(succeeded, run_name=run_name)
示例#21
0
        # The first option has the benifit of the standard __main__ syntax,
        # but the second option allows for use of the callbacks.
        #
        # The prefered method for opus tools is the second option
        #
        # EXAMPLE
        #
        try:
            importString = "from %s import opusRun" % (self.toolInclude)
            #print importString
            exec(importString)
            self.params = self.buildparams()
            if self.startingCallback != None:
                self.startingCallback()
            success = opusRun(self.progressCallback,self.logCallback,self.toolVars) #@UndefinedVariable
            if self.finishedCallback != None:
                self.progressCallback(100)
                self.finishedCallback(success)
        except ImportError, e:
            print "ImportError: %s" % formatExceptionInfo()
            success = False
            self.logCallback("Error importing %s: %s" % (self.toolInclude, formatExceptionInfo()) )
            self.finishedCallback(success)
        except:
            success = False
            errorInfo = formatExceptionInfo(custom_message = 'Unexpected Error From Tool',plainText=True)
            #self.logCallback("Unexpected Error From Tool %s" % (self.toolInclude))
            self.logCallback(errorInfo)
            self.finishedCallback(success)

示例#22
0
        #
        # The prefered method for opus tools is the second option
        #
        # EXAMPLE
        #
        try:
            importString = "from %s import opusRun" % (self.toolInclude)
            #print importString
            exec(importString)
            self.params = self.buildparams()
            if self.startingCallback != None:
                self.startingCallback()
            success = opusRun(self.progressCallback, self.logCallback,
                              self.toolVars)  #@UndefinedVariable
            if self.finishedCallback != None:
                self.progressCallback(100)
                self.finishedCallback(success)
        except ImportError, e:
            print "ImportError: %s" % formatExceptionInfo()
            success = False
            self.logCallback("Error importing %s: %s" %
                             (self.toolInclude, formatExceptionInfo()))
            self.finishedCallback(success)
        except:
            success = False
            errorInfo = formatExceptionInfo(
                custom_message='Unexpected Error From Tool', plainText=True)
            #self.logCallback("Unexpected Error From Tool %s" % (self.toolInclude))
            self.logCallback(errorInfo)
            self.finishedCallback(success)