Exemplo n.º 1
0
 def setUp(self):
     FrameworkManagerImpl.Instance()
     self._alg_factory = AlgorithmFactory.Instance()
     self._alg_factory.subscribe(_ParamTester)
     if self._load is None:
         self.__class__._load = AlgorithmManager.createUnmanaged('Load')
         self._load.initialize()
Exemplo n.º 2
0
    def get_algorithm_data(self):
        """
        Prepare the algorithm description data for displaying in the view.
        :return: A tuple of two elements. The first is a list of all algorithm names.
            This always contains all known algorithms regardless of their hidden state
            The second is a tree of nested dicts where keys either category names
            or self.algorithm_key. Values of the category names are sub-trees
            and those of self.algorithm_key have dicts mapping algorithm names
            to lists of their versions. For example (as yaml):

                Arithmetic:
                  Errors:
                    _:
                      PoissonErrors: [1]
                      SetUncertainties: [1]
                      SignalOverError: [1]
                  FFT:
                    _:
                      ExtractFFTSpectrum: [1]
                      FFT: [1]
                      FFTDerivative: [1]
                      FFTSmooth: [1, 2]
                  _:
                    CrossCorrelate: [1]
                    Divide: [1]
                    Exponential: [1]
                    GeneralisedSecondDifference: [1]

            Here self.algorithm_key == '_'

        """
        include_alias = True
        algm_factory = AlgorithmFactory.Instance()
        descriptors = algm_factory.getDescriptors(self.include_hidden, include_alias)
        data = {}
        for descriptor in descriptors:
            categories = descriptor.category.split(CATEGORY_SEP)
            # Create nested dictionaries in which the key is a category and the value
            # is a similar dictionary with sub-categories as keys
            d = data
            for cat in categories:
                if cat not in d:
                    d[cat] = {}
                d = d[cat]
            # Entry with key == '' contains a dict with algorithm names as keys
            # The values are lists of version numbers
            if self.algorithm_key not in d:
                d[self.algorithm_key] = {}
            d = d[self.algorithm_key]
            if descriptor.name not in d:
                d[descriptor.name] = []
            d[descriptor.name].append(descriptor.version)

        # Add hidden algs to search box (hidden on tree)
        include_hidden = True
        unique_alg_names = set(descr.name
                               for descr in algm_factory.getDescriptors(include_hidden, include_alias))
        return sorted(unique_alg_names), data
Exemplo n.º 3
0
    def post_mantid_init(self):
        """Run any setup that requires mantid
        to have been initialized
        """
        self.populate_menus()
        self.algorithm_selector.refresh()

        # turn on algorithm factory notifications
        from mantid.api import AlgorithmFactory
        algorithm_factory = AlgorithmFactory.Instance()
        algorithm_factory.enableNotifications()
Exemplo n.º 4
0
    def create_mantid_algorithm(self, algorithm_name, version=-1):
        """
        Create and initializes a Mantid algorithm.

        Args:
          algorithm_name (str): The name of the algorithm to use for the title.
          version (int): Version of the algorithm to create

        Returns:
          algorithm: An instance of a Mantid algorithm.
        """
        if version == -1:
            version = AlgorithmFactory.Instance().highestVersion(
                algorithm_name)
        alg = AlgorithmManager.Instance().createUnmanaged(
            algorithm_name, version)
        alg.initialize()
        return alg
Exemplo n.º 5
0
 def set_algorithm_tree_categories(self):
     widget = self.view.algorithm_tree_widget
     widget.setHeaderLabel("Show/Hide Algorithm Categories")
     category_map = AlgorithmFactory.Instance().getCategoriesandState()
     self._set_tree_categories(widget, category_map)
Exemplo n.º 6
0
 def setUp(self):
     self._alg_factory = AlgorithmFactory.Instance()
     self._alg_factory.enableNotifications()
Exemplo n.º 7
0
 def setUp(self):
     self.fake_class = FakeAlgorithmFactoryObserver()
     self.fake_class.updateHandle = mock.MagicMock()
     self._alg_factory = AlgorithmFactory.Instance()
     self._alg_factory.disableNotifications()
Exemplo n.º 8
0
 def set_algorithm_tree_categories(self):
     widget = self.view.algorithm_tree_widget
     category_map = AlgorithmFactory.Instance().getCategoriesandState()
     self._set_tree_categories(widget, category_map)