Пример #1
0
def find_data(file, instrument='', allow_multiple=False):
    """
        Finds a file path for the specified data set, which can either be:
            - a run number
            - an absolute path
            - a file name
        @param file: file name or part of a file name
        @param instrument: if supplied, FindNeXus will be tried as a last resort
    """
    # First, assume a file name
    file = str(file).strip()

    # If we allow multiple files, users may use ; as a separator,
    # which is incompatible with the FileFinder
    n_files = 1
    if allow_multiple:
        file = file.replace(';', ',')
        toks = file.split(',')
        n_files = len(toks)

    instrument = str(instrument)
    file_path = FileFinder.getFullPath(file)
    if os.path.isfile(file_path):
        return file_path

    # Second, assume a run number and pass the instrument name as a hint
    try:
        # FileFinder doesn't like dashes...
        instrument = instrument.replace('-', '')
        f = FileFinder.findRuns(instrument + file)
        if os.path.isfile(f[0]):
            if allow_multiple:
                # Mantid returns its own list object type, so make a real list out if it
                if len(f) == n_files:
                    return [i for i in f]
            else:
                return f[0]
    except:
        # FileFinder couldn't make sense of the the supplied information
        pass

    # Third, assume a run number, without instrument name to take care of list of full paths
    try:
        f = FileFinder.findRuns(file)
        if os.path.isfile(f[0]):
            if allow_multiple:
                # Mantid returns its own list object type, so make a real list out if it
                if len(f) == n_files:
                    return [i for i in f]
            else:
                return f[0]
    except:
        # FileFinder couldn't make sense of the the supplied information
        pass

    # If we didn't find anything, raise an exception
    Logger('find_data').error(
        "\n\nCould not find a file for %s: check your reduction parameters\n\n"
        % str(file))
    raise RuntimeError, "Could not find a file for %s" % str(file)
Пример #2
0
    def validateASCII(self):
        """Validate ASCII files using difflib."""
        (measured, expected) = self.validate()
        if not os.path.isabs(measured):
            measured = FileFinder.Instance().getFullPath(measured)
        if not os.path.isabs(expected):
            expected = FileFinder.Instance().getFullPath(expected)

        measured = self.__prepASCIIFile(measured)
        expected = self.__prepASCIIFile(expected)

        # calculate the difference
        diff = difflib.Differ().compare(measured, expected)
        result = []
        for line in diff:
            if line.startswith('+') or line.startswith('-') or line.startswith('?'):
                result.append(line)

        # print the difference
        if len(result) > 0:
            if self.stripWhitespace:
                msg = "(whitespace striped from ends)"
            else:
                msg = ""
            print("******************* Difference in files", msg)
            print("\n".join(result))
            print("*******************")
            return False
        else:
            return True
Пример #3
0
def find_data(file, instrument='', allow_multiple=False):
    """
        Finds a file path for the specified data set, which can either be:
            - a run number
            - an absolute path
            - a file name
        @param file: file name or part of a file name
        @param instrument: if supplied, FindNeXus will be tried as a last resort
    """
    # First, assume a file name
    file = str(file).strip()

    # If we allow multiple files, users may use ; as a separator,
    # which is incompatible with the FileFinder
    n_files = 1
    if allow_multiple:
        file=file.replace(';',',')
        toks = file.split(',')
        n_files = len(toks)

    instrument = str(instrument)
    file_path = FileFinder.getFullPath(file)
    if os.path.isfile(file_path):
        return file_path

    # Second, assume a run number and pass the instrument name as a hint
    try:
        # FileFinder doesn't like dashes...
        instrument=instrument.replace('-','')
        f = FileFinder.findRuns(instrument+file)
        if os.path.isfile(f[0]):
            if allow_multiple:
                # Mantid returns its own list object type, so make a real list out if it
                if len(f)==n_files:
                    return [i for i in f]
            else:
                return f[0]
    except:
        # FileFinder couldn't make sense of the the supplied information
        pass

    # Third, assume a run number, without instrument name to take care of list of full paths
    try:
        f = FileFinder.findRuns(file)
        if os.path.isfile(f[0]):
            if allow_multiple:
                # Mantid returns its own list object type, so make a real list out if it
                if len(f)==n_files:
                    return [i for i in f]
            else:
                return f[0]
    except:
        # FileFinder couldn't make sense of the the supplied information
        pass

    # If we didn't find anything, raise an exception
    Logger('find_data').error("\n\nCould not find a file for %s: check your reduction parameters\n\n" % str(file))
    raise RuntimeError("Could not find a file for %s" % str(file))
Пример #4
0
    def FileExists(filename):
        if os.path.exists(filename):
            return True

        # or use filefinder to search
        try:
            FileFinder.findRuns(filename)
            return True
        except:
            return False
Пример #5
0
def _is_mantid_loadable(filename):
    from mantid.api import FileFinder
    if FileFinder.getFullPath(filename):
        return True
    else:
        try:
            # findRuns throws rather than return empty so need try-catch
            FileFinder.findRuns(filename)
            return True
        except Exception:
            return False
Пример #6
0
 def test_that_find_runs_accepts_a_list_of_string_and_a_bool(self):
     try:
         runs = FileFinder.findRuns("CNCS7860", useExtsOnly=True)
         FileFinder.findRuns("CNCS7860", [".nxs", ".txt"], useExtsOnly=True)
     except Exception as e:
         if type(e).__name__ == "ArgumentError":
             self.assertFalse(True, "Expected findRuns to accept a list of strings and a bool as input."
                                    " {} error was raised with message {}".format(type(e).__name__, str(e)))
     else:
         # Confirm that it works as above
         self.assertTrue(len(runs) == 1)
         self.assertTrue(os.path.exists(runs[0]))
    def test_runinfo_correct(self):
        file_path = FileFinder.findRuns('MUSR00022725.nxs')[0]
        ws, run, filename, _ = load_utils.load_workspace_from_filename(
            file_path)
        self.data_context._loaded_data.remove_data(run=run)
        self.data_context._loaded_data.add_data(run=[run],
                                                workspace=ws,
                                                filename=filename,
                                                instrument='MUSR')
        self.data_context.current_runs = [[22725]]
        self.context.update_current_data()
        test_pair = MuonPair('test_pair', 'top', 'bottom', alpha=0.75)
        self.group_context.add_pair(pair=test_pair)

        self.presenter.update_view_from_model()

        expected = [
            call("Instrument                : MUSR"),
            call("Run                       : 22725"),
            call("Title                     : FeTeSe T=1 F=100"),
            call("Comment                   : FC first sample"),
            call("Start                     : 2009-03-24T04:18:58"),
            call("End                       : 2009-03-24T04:56:26"),
            call("Counts (MEv)              : 20.076704"),
            call("Good Frames               : 88540"),
            call("Counts per Good Frame     : 226.753"),
            call("Counts per Good Frame per det : 3.543"),
            call("Average Temperature (K)   : 19.69992"),
            call("Sample Temperature (K)    : 1.0"),
            call("Sample Magnetic Field (G) : 100.0"),
            call("Number of DAQ Periods     : 1")
        ]

        self.assertEqual(self.view.add_text_line.call_args_list, expected)
Пример #8
0
    def setUp(self):
        self._qapp = mock_widget.mockQapp()
        # Store an empty widget to parent all the views, and ensure they are deleted correctly
        self.obj = QtWidgets.QWidget()
        setup_context_for_tests(self)

        self.data_context.instrument = 'MUSR'

        self.gui_context.update({'RebinType': 'None'})
        self.model = maxent_model.MaxEntModel()

        self.view = maxent_view_new.MaxEntView(self.obj)

        self.presenter = maxent_presenter_new.MaxEntPresenter(self.view, self.context)

        file_path = FileFinder.findRuns('MUSR00022725.nxs')[0]
        ws, run, filename = load_utils.load_workspace_from_filename(file_path)
        self.data_context._loaded_data.remove_data(run=run)
        self.data_context._loaded_data.add_data(run=[run], workspace=ws, filename=filename, instrument='MUSR')
        self.data_context.current_runs = [[22725]]

        self.context.update_current_data()
        test_pair = MuonPair('test_pair', 'top', 'bottom', alpha=0.75)
        self.group_context.add_pair(pair=test_pair)

        self.view.warning_popup = mock.MagicMock()
    def setUp(self):
        self._qapp = mock_widget.mockQapp()
        # Store an empty widget to parent all the views, and ensure they are deleted correctly
        self.obj = QtGui.QWidget()
        ConfigService['default.instrument'] = 'MUSR'

        setup_context_for_tests(self)
        self.context.instrument = 'MUSR'
        self.load_file_view = BrowseFileWidgetView(self.obj)
        self.load_run_view = LoadRunWidgetView(self.obj)
        self.load_file_model = BrowseFileWidgetModel(self.loaded_data, self.context)
        self.load_run_model = LoadRunWidgetModel(self.loaded_data, self.context)

        self.view = LoadWidgetView(parent=self.obj, load_file_view=self.load_file_view,
                                   load_run_view=self.load_run_view)
        self.presenter = LoadWidgetPresenter(self.view, LoadWidgetModel(self.loaded_data, self.context))
        self.presenter.set_load_file_widget(BrowseFileWidgetPresenter(self.load_file_view, self.load_file_model))
        self.presenter.set_load_run_widget(LoadRunWidgetPresenter(self.load_run_view, self.load_run_model))

        self.presenter.load_file_widget._view.warning_popup = mock.MagicMock()
        self.presenter.load_run_widget._view.warning_popup = mock.MagicMock()

        self.view.multiple_loading_check.setCheckState(1)
        self.presenter.handle_multiple_files_option_changed()

        self.runs = [15196, 15197]
        self.workspaces = [self.create_fake_workspace(1) for _ in self.runs]
        self.filenames = FileFinder.findRuns('MUSR00015196.nxs, MUSR00015197.nxs')
Пример #10
0
    def __verifyRequiredFile(self, filename):
        '''Return True if the specified file name is findable by Mantid.'''
        from mantid.api import FileFinder

        # simple way is just getFullPath which never uses archive search
        if os.path.exists(FileFinder.getFullPath(filename)):
            return True

        # try full findRuns which will use archive search if it is turned on
        try:
            candidates = FileFinder.findRuns(filename)
            for item in candidates:
                if os.path.exists(item):
                    return True
        except RuntimeError, e:
            return False
    def setUp(self):
        # Store an empty widget to parent all the views, and ensure they are deleted correctly
        self.obj = QWidget()
        ConfigService['default.instrument'] = 'MUSR'

        setup_context_for_tests(self)
        self.context.instrument = 'MUSR'
        self.load_file_view = BrowseFileWidgetView(self.obj)
        self.load_run_view = LoadRunWidgetView(self.obj)
        self.load_file_model = BrowseFileWidgetModel(self.loaded_data,
                                                     self.context)
        self.load_run_model = LoadRunWidgetModel(self.loaded_data,
                                                 self.context)

        self.view = LoadWidgetView(parent=self.obj,
                                   load_file_view=self.load_file_view,
                                   load_run_view=self.load_run_view)
        self.presenter = LoadWidgetPresenter(
            self.view, LoadWidgetModel(self.loaded_data, self.context))
        self.presenter.set_load_file_widget(
            BrowseFileWidgetPresenter(self.load_file_view,
                                      self.load_file_model))
        self.presenter.set_load_run_widget(
            LoadRunWidgetPresenter(self.load_run_view, self.load_run_model))

        self.presenter.load_file_widget._view.warning_popup = mock.MagicMock()
        self.presenter.load_run_widget._view.warning_popup = mock.MagicMock()

        self.view.multiple_loading_check.setCheckState(1)
        self.presenter.handle_multiple_files_option_changed()

        self.runs = [15196, 15197]
        self.workspaces = [self.create_fake_workspace(1) for _ in self.runs]
        self.filenames = FileFinder.findRuns(
            'MUSR00015196.nxs, MUSR00015197.nxs')
    def _run(self):
        '''Defines the workflow for the test'''
        self.tolerance = 1e-2
        self.samples = [sample[:-4] for sample in self.samples]

        #load files into mantid
        for sample in self.samples:
            LoadNexus(sample, OutputWorkspace=sample)
        LoadNexus(FileFinder.getFullPath(self.resolution),
                  OutputWorkspace=self.resolution)

        _, iqt_ws = TransformToIqt(SampleWorkspace=self.samples[0],
                                   ResolutionWorkspace=self.resolution,
                                   EnergyMin=self.e_min,
                                   EnergyMax=self.e_max,
                                   BinReductionFactor=self.num_bins,
                                   DryRun=False,
                                   NumberOfIterations=200)

        # Test IqtFitMultiple
        iqtfitSeq_ws, params, fit_group = IqtFitMultiple(
            iqt_ws.name(), self.func, self.ftype, self.startx, self.endx,
            self.spec_min, self.spec_max)

        self.result_names = [iqt_ws.name(), iqtfitSeq_ws.name()]

        #remove workspaces from mantid
        for sample in self.samples:
            DeleteWorkspace(sample)
        DeleteWorkspace(params)
        DeleteWorkspace(fit_group)
        DeleteWorkspace(self.resolution)
Пример #13
0
    def runTest(self):
        UseCompatibilityMode()
        LOQ()
        Detector("main-detector-bank")
        csv_file = FileFinder.getFullPath('batch_input.csv')

        Set1D()
        MaskFile('MASK.094AA')
        Gravity(True)

        BatchReduce(csv_file,
                    'raw',
                    plotresults=False,
                    saveAlgs={
                        'SaveCanSAS1D': 'xml',
                        'SaveNexus': 'nxs'
                    })

        LoadNexus(Filename='54433sans.nxs', OutputWorkspace='result')
        Plus(LHSWorkspace='result',
             RHSWorkspace='99630sanotrans',
             OutputWorkspace='result')

        os.remove(
            os.path.join(config['defaultsave.directory'], '54433sans.nxs'))
        os.remove(
            os.path.join(config['defaultsave.directory'],
                         '99630sanotrans.nxs'))
        os.remove(
            os.path.join(config['defaultsave.directory'], '54433sans.xml'))
        os.remove(
            os.path.join(config['defaultsave.directory'],
                         '99630sanotrans.xml'))
Пример #14
0
    def __verifyRequiredFile(self, filename):
        '''Return True if the specified file name is findable by Mantid.'''
        from mantid.api import FileFinder

        # simple way is just getFullPath which never uses archive search
        if os.path.exists(FileFinder.getFullPath(filename)):
            return True

        # try full findRuns which will use archive search if it is turned on
        try:
            candidates = FileFinder.findRuns(filename)
            for item in candidates:
                if os.path.exists(item):
                    return True
        except RuntimeError, e:
            return False
    def setUp(self):
        self.context = setup_context(True)

        self.context.data_context.instrument = 'MUSR'

        self.context.gui_context.update({'RebinType': 'None'})
        self.model = maxent_model.MaxEntModel()

        self.view = maxent_view_new.MaxEntView()

        self.presenter = maxent_presenter_new.MaxEntPresenter(
            self.view, self.context)

        file_path = FileFinder.findRuns('MUSR00022725.nxs')[0]
        ws, run, filename, _ = load_utils.load_workspace_from_filename(
            file_path)
        self.context.data_context._loaded_data.remove_data(run=run)
        self.context.data_context._loaded_data.add_data(run=[run],
                                                        workspace=ws,
                                                        filename=filename,
                                                        instrument='MUSR')
        self.context.data_context.current_runs = [[22725]]

        self.context.update_current_data()
        test_pair = MuonPair('test_pair', 'top', 'bottom', alpha=0.75)
        self.context.group_pair_context.add_pair(pair=test_pair)

        self.view.warning_popup = mock.MagicMock()
    def setUp(self):
        self.context = setup_context(True)

        self.context.data_context.instrument = 'MUSR'

        self.context.gui_context.update({'RebinType': 'None'})

        self.view = fft_view_new.FFTView()
        self.model1 = fft_model.FFTModel()
        self.model = fft_model.FFTWrapper

        self.presenter = fft_presenter_new.FFTPresenter(
            self.view, self.model, self.context)

        file_path = FileFinder.findRuns('MUSR00022725.nxs')[0]
        ws, run, filename, _ = load_utils.load_workspace_from_filename(file_path)
        self.context.data_context._loaded_data.remove_data(run=run)
        self.context.data_context._loaded_data.add_data(run=[run], workspace=ws, filename=filename, instrument='MUSR')
        self.context.data_context.current_runs = [[22725]]

        self.context.update_current_data()
        test_pair = MuonPair(EXAMPLE_PAIR, 'top', 'bottom', alpha=0.75)
        self.context.group_pair_context.add_pair(pair=test_pair)
        self.context.show_all_groups()
        self.context.show_all_pairs()
        self.context.group_pair_context._selected_groups = GROUP_LIST
        self.context.group_pair_context._selected_pairs = [EXAMPLE_PAIR]

        self.view.warning_popup = mock.MagicMock()
Пример #17
0
def get_current_run_filename(instrument):
    """
    If instrument is supported, attempts to find the file on the ISIS network which
    contains the data from its current (most up-to-date) run.
    """

    instrument_directory = get_instrument_directory(instrument)
    if instrument_directory is None:
        return ""

    file_path = _instrument_data_directory(instrument_directory) + FILE_SEP
    autosave_file_name = file_path + "autosave.run"
    current_run_filename = ""
    if not check_file_exists(autosave_file_name):
        raise ValueError("Cannot find file : " + autosave_file_name)
    with open(autosave_file_name, 'r') as autosave_file:
        for line in autosave_file:
            line.replace(" ", "")
            file_name = file_path + line
            if check_file_exists(FileFinder.getFullPath(file_name)):
                current_run_filename = file_name
    if current_run_filename == "":
        # Default to auto_A (replicates MuonAnalysis 1.0 behaviour)
        current_run_filename = file_path + instrument_directory + "auto_A.tmp"
        warning("Failed to find latest run, defaulting to " +
                current_run_filename)

    return current_run_filename
Пример #18
0
def find_sans_file(file_name):
    """
    Finds a SANS file.
    The file can be specified as:
    1. file.ext or  path1 path2 file.ext
    2. run number
    :param file_name: a file name or a run number.
    :return: the full path.
    """
    full_path = find_full_file_path(file_name)
    if not full_path and not file_name.endswith('.nxs'):
        full_path = find_full_file_path(file_name + '.nxs')
    if not full_path:
        # TODO: If we only provide a run number for example 98843 for LOQ measurments, but have LARMOR specified as the
        #       Mantid instrument, then the FileFinder will search itself to death. This is a general Mantid issue.
        #       One way to handle this graceful would be a timeout option.
        runs = FileFinder.findRuns(file_name)
        if runs:
            full_path = runs[0]

    if not full_path:
        error_message = "Trying to find the SANS file {0}, but cannot find it. Make sure that " \
                        "the relevant paths are added and the correct instrument is selected."
        raise RuntimeError(error_message.format(file_name))
    return full_path
Пример #19
0
def find_sans_file(file_name):
    """
    Finds a SANS file.
    The file can be specified as:
    1. file.ext or  path1 path2 file.ext
    2. run number
    :param file_name: a file name or a run number.
    :return: the full path.
    """
    error_message = "Trying to find the SANS file {0}, but cannot find it. Make sure that "\
                    "the relevant paths are added and the correct instrument is selected."
    try:
        full_path = find_full_file_path(file_name)
        if not full_path and not file_name.endswith('.nxs'):
            full_path = find_full_file_path(file_name + '.nxs')
        if not full_path:
            # TODO: If we only provide a run number for example 98843 for LOQ measurments, but have LARMOR specified as the
            #       Mantid instrument, then the FileFinder will search itself to death. This is a general Mantid issue.
            #       One way to handle this graceful would be a timeout option.
            file_name_as_bytes = str.encode(file_name)
            assert(type(file_name_as_bytes) == bytes)
            runs = FileFinder.findRuns(file_name_as_bytes)
            if runs:
                full_path = runs[0]
    except RuntimeError:
        raise RuntimeError(error_message.format(file_name))

    if not full_path:
        raise RuntimeError(error_message.format(file_name))
    return full_path
    def _run(self):
        '''Defines the workflow for the test'''
        self.tolerance = 1e-3
        self.samples = [sample[:-4] for sample in self.samples]

        # Load files into Mantid
        for sample in self.samples:
            LoadNexus(sample, OutputWorkspace=sample)
        LoadNexus(FileFinder.getFullPath(self.resolution), OutputWorkspace=self.resolution)

        _, iqt_ws = TransformToIqt(SampleWorkspace=self.samples[0],
                                   ResolutionWorkspace=self.resolution,
                                   EnergyMin=self.e_min,
                                   EnergyMax=self.e_max,
                                   BinReductionFactor=self.num_bins,
                                   DryRun=False,
                                   NumberOfIterations=200)

        # Test IqtFit Sequential
        iqtfitSeq_ws, params, fit_group = IqtFitSequential(InputWorkspace=iqt_ws, Function=self.func,
                                                           StartX=self.startx, EndX=self.endx,
                                                           SpecMin=0, SpecMax=self.spec_max)

        self.result_names = [iqt_ws.name(),
                             iqtfitSeq_ws[0].name()]

        # Remove workspaces from Mantid
        for sample in self.samples:
            DeleteWorkspace(sample)
        DeleteWorkspace(params)
        DeleteWorkspace(fit_group)
        DeleteWorkspace(self.resolution)
    def getDataFileNames(self, runsetupdict, advsetupdict):
        """ Obtain the data file names (run names + SUFFIX)

        Return: list of files
        """

        runnumbers_str = str(runsetupdict["RunNumber"])
        if runnumbers_str.count(':') > 0:
            runnumbers_str = runnumbers_str.replace(':', '-')
        runnumbers_str = FileFinder.findRuns('{}{}'.format(self.instrument_name, runnumbers_str))
        runnumbers_str = [os.path.split(filename)[-1] for filename in runnumbers_str]

        # create an integer version
        runnumbers = []
        for filename in runnumbers_str:
            for extension in ['_event.nxs', '.nxs.h5']:
                filename = filename.replace(extension, '')
            runnumber = filename.split('_')[-1]
            runnumbers.append(int(runnumber))

        # put together the output
        datafilenames = []
        for (filename, runnumber) in zip(runnumbers_str, runnumbers):
            datafilenames.append((runnumber, filename))

        return datafilenames
    def setUp(self):
        self._qapp = mock_widget.mockQapp()
        self.obj = QtGui.QWidget()
        ConfigService['default.instrument'] = 'MUSR'
        setup_context_for_tests(self)
        self.gui_context['RebinType'] = 'None'
        self.view = HomeGroupingWidgetView(self.obj)
        self.model = HomeGroupingWidgetModel(self.context)
        self.presenter = HomeGroupingWidgetPresenter(self.view, self.model)

        self.view.warning_popup = mock.MagicMock()
        self.view.instrument_changed_warning = mock.MagicMock(return_value=1)

        file_path = FileFinder.findRuns('MUSR00022725.nxs')[0]
        ws, run, filename = load_utils.load_workspace_from_filename(file_path)
        self.data_context._loaded_data.remove_data(run=run)
        self.data_context._loaded_data.add_data(run=[run],
                                                workspace=ws,
                                                filename=filename,
                                                instrument='MUSR')
        self.data_context.current_runs = [[22725]]

        self.context.update_current_data()
        test_pair = MuonPair('test_pair', 'top', 'bottom', alpha=0.75)
        self.group_context.add_pair(pair=test_pair)
        self.presenter.update_group_pair_list()
Пример #23
0
    def setUp(self):
        AnalysisDataService.clear()
        ConfigService['MantidOptions.InvisibleWorkspaces'] = 'True'
        self.filepath = FileFinder.findRuns('EMU00019489.nxs')[0]

        self.load_result, self.run_number, self.filename, psi_data = load_workspace_from_filename(
            self.filepath)
        self.assert_(not psi_data)

        self.context = setup_context(True)
        self.context.gui_context.update({'RebinType': 'None'})
        self.loaded_data = self.context.data_context._loaded_data
        self.data_context = self.context.data_context
        self.gui_context = self.context.gui_context
        self.group_pair_context = self.context.group_pair_context
        self.data_context.instrument = 'EMU'

        self.loaded_data.add_data(workspace=self.load_result,
                                  run=[self.run_number],
                                  filename=self.filename,
                                  instrument='EMU')
        self.data_context.current_runs = [[self.run_number]]
        self.data_context.update_current_data()
        self.group_pair_context.reset_group_and_pairs_to_default(
            self.load_result['OutputWorkspace'][0].workspace, 'EMU', '', 1)
Пример #24
0
 def cleanup(self):
     Files = ["TOPAZ_3132.hkl", "TOPAZ_3132FFT.hkl"]
     for filename in Files:
         absfile = FileFinder.getFullPath(filename)
         if os.path.exists(absfile):
             os.remove(absfile)
     return True
Пример #25
0
    def _create_peaks_workspace(self):
        """Create a dummy peaks workspace"""
        path = FileFinder.getFullPath("IDFs_for_UNIT_TESTING/MINITOPAZ_Definition.xml")
        inst = LoadEmptyInstrument(Filename=path)
        ws = CreatePeaksWorkspace(inst, 0)
        DeleteWorkspace(inst)
        SetUB(ws, 1, 1, 1, 90, 90, 90)

        # Add a bunch of random peaks that happen to fall on the
        # detetor bank defined in the IDF
        center_q = np.array([-5.1302,2.5651,3.71809])
        qs = []
        for i in np.arange(0, 1, 0.1):
            for j in np.arange(-0.5, 0, 0.1):
                q = center_q.copy()
                q[1] += j
                q[2] += i
                qs.append(q)

        # Add the peaks to the PeaksWorkspace with dummy values for intensity,
        # Sigma, and HKL
        for q in qs:
            peak = ws.createPeak(q)
            peak.setIntensity(100)
            peak.setSigmaIntensity(10)
            peak.setHKL(1, 1, 1)
            ws.addPeak(peak)

        return ws
Пример #26
0
    def test_get_pair_phasequad_name(self):
        AnalysisDataService.clear()
        ConfigService['MantidOptions.InvisibleWorkspaces'] = 'True'
        filepath = FileFinder.findRuns('EMU00019489.nxs')[0]

        load_result, run_number, filename, psi_data = load_workspace_from_filename(
            filepath)

        context = setup_context()
        context.gui_context.update({'RebinType': 'None'})
        context.data_context.instrument = 'EMU'

        context.data_context._loaded_data.add_data(workspace=load_result,
                                                   run=[run_number],
                                                   filename=filename,
                                                   instrument='EMU')
        context.data_context.current_runs = [[run_number]]
        context.data_context.update_current_data()

        self.assertEqual(
            "EMU19489; PhaseQuad; test_Re; MA",
            get_pair_phasequad_name(context, "test_Re", "19489", False))
        self.assertEqual(
            "EMU19489; PhaseQuad; test_Re; Rebin; MA",
            get_pair_phasequad_name(context, "test_Re", "19489", True))
    def test_runinfo_correct(self):
        file_path = FileFinder.findRuns('MUSR00022725.nxs')[0]
        ws, run, filename = load_utils.load_workspace_from_filename(file_path)
        self.data_context._loaded_data.remove_data(run=run)
        self.data_context._loaded_data.add_data(run=[run],
                                                workspace=ws,
                                                filename=filename,
                                                instrument='MUSR')
        self.data_context.current_runs = [[22725]]
        self.context.update_current_data()
        test_pair = MuonPair('test_pair', 'top', 'bottom', alpha=0.75)
        self.group_context.add_pair(pair=test_pair)

        self.presenter.update_view_from_model()

        expected_string_list = [
            'Instrument:MUSR', 'Run:22725', 'Title:FeTeSeT=1F=100',
            'Comment:FCfirstsample', 'Start:2009-03-24T04:18:58',
            'End:2009-03-24T04:56:26', 'Counts(MEv):20.076704',
            'GoodFrames:88540', 'CountsperGoodFrame:226.753',
            'CountsperGoodFrameperdet:3.543', 'AverageTemperature(K):2.53386',
            'SampleTemperature(K):1.0', 'SampleMagneticField(G):100.0'
        ]

        self.assertEqual(
            str(self.view.run_info_box.toPlainText()).replace(' ',
                                                              '').splitlines(),
            expected_string_list)
Пример #28
0
    def runTest(self):
        UseCompatibilityMode()
        config['default.instrument'] = 'SANS2D'
        SANS2DTUBES()
        Set1D()
        Detector("rear-detector")
        # This contains two MASKFILE commands, each resulting in a separate call to MaskDetectors.
        MaskFile('SANS2DTube_ZerroErrorFreeTest.txt')

        # Saves a file which produces an output file which does not contain any zero errors
        csv_file = FileFinder.getFullPath(
            "SANS2DTUBES_ZeroErrorFree_batch.csv")
        save_alg = {"SaveNexus": "nxs"}
        BatchReduce(csv_file,
                    'nxs',
                    saveAlgs=save_alg,
                    plotresults=False,
                    save_as_zero_error_free=True)
        DeleteWorkspace('zero_free_out_rear_1D_1.75_12.5')

        # The zero correction only occurs for the saved files. Stephen King mentioned that the
        # original workspaces should not be tampered with
        self._final_output = os.path.join(
            config['defaultsave.directory'],
            'zero_free_out_rear_1D_1.75_12.5.nxs')
        self._final_workspace = 'ws'
        Load(Filename=self._final_output,
             OutputWorkspace=self._final_workspace)
Пример #29
0
    def setUp(self):
        AnalysisDataService.clear()
        self.filepath = FileFinder.findRuns('EMU00019489.nxs')[0]
        self.load_result, self.run_number, self.filename = load_workspace_from_filename(
            self.filepath)
        self.loaded_data = MuonLoadData()
        self.data_context = MuonDataContext(self.loaded_data)
        self.gui_context = MuonGuiContext()
        self.group_pair_context = MuonGroupPairContext()
        self.gui_context.update({'RebinType': 'None'})

        self.context = MuonContext(muon_data_context=self.data_context,
                                   muon_gui_context=self.gui_context,
                                   muon_group_context=self.group_pair_context)

        self.data_context.instrument = 'EMU'

        self.loaded_data.add_data(workspace=self.load_result,
                                  run=[self.run_number],
                                  filename=self.filename,
                                  instrument='EMU')
        self.data_context.current_runs = [[self.run_number]]
        self.data_context.update_current_data()
        self.group_pair_context.reset_group_and_pairs_to_default(
            self.load_result['OutputWorkspace'][0]._workspace, 'EMU', '')
Пример #30
0
    def _run(self):
        '''Defines the workflow for the test'''
        self.tolerance = 1e-7
        self.samples = [sample[:-4] for sample in self.samples]

        # Load files into Mantid
        for sample in self.samples:
            LoadNexus(sample, OutputWorkspace=sample)
        LoadNexus(FileFinder.getFullPath(self.resolution),
                  OutputWorkspace=self.resolution)

        _, iqt_ws = TransformToIqt(SampleWorkspace=self.samples[0],
                                   ResolutionWorkspace=self.resolution,
                                   EnergyMin=self.e_min,
                                   EnergyMax=self.e_max,
                                   BinReductionFactor=self.num_bins,
                                   DryRun=False)

        # Test IqtFit Sequential
        iqtfitSeq_ws, params, fit_group = IqtFitSequential(
            InputWorkspace=iqt_ws,
            Function=self.func,
            StartX=self.startx,
            EndX=self.endx,
            SpecMin=0,
            SpecMax=self.spec_max)

        self.result_names = [iqt_ws.name(), iqtfitSeq_ws.name()]

        # Remove workspaces from Mantid
        for sample in self.samples:
            DeleteWorkspace(sample)
        DeleteWorkspace(params)
        DeleteWorkspace(fit_group)
        DeleteWorkspace(self.resolution)
Пример #31
0
    def getDataFileNames(self, runsetupdict, advsetupdict):
        """ Obtain the data file names (run names + SUFFIX)

        Return: list of files
        """

        runnumbers_str = str(runsetupdict["RunNumber"])
        if runnumbers_str.count(':') > 0:
            runnumbers_str = runnumbers_str.replace(':', '-')
        runnumbers_str = FileFinder.findRuns('{}{}'.format(self.instrument_name, runnumbers_str))
        runnumbers_str = [os.path.split(filename)[-1] for filename in runnumbers_str]

        # create an integer version
        runnumbers = []
        for filename in runnumbers_str:
            for extension in ['_event.nxs', '.nxs.h5']:
                filename = filename.replace(extension, '')
            runnumber = filename.split('_')[-1]
            runnumbers.append(int(runnumber))

        # put together the output
        datafilenames = []
        for (filename, runnumber) in zip(runnumbers_str, runnumbers):
            datafilenames.append((runnumber, filename))

        return datafilenames
Пример #32
0
    def _create_peaks_workspace(self):
        """Create a dummy peaks workspace"""
        path = FileFinder.getFullPath(
            "IDFs_for_UNIT_TESTING/MINITOPAZ_Definition.xml")
        inst = LoadEmptyInstrument(Filename=path)
        ws = CreatePeaksWorkspace(inst, 0)
        DeleteWorkspace(inst)
        SetUB(ws, 1, 1, 1, 90, 90, 90)

        # Add a bunch of random peaks that happen to fall on the
        # detetor bank defined in the IDF
        center_q = np.array([-5.1302, 2.5651, 3.71809])
        qs = []
        for i in np.arange(0, 1, 0.1):
            for j in np.arange(-0.5, 0, 0.1):
                q = center_q.copy()
                q[1] += j
                q[2] += i
                qs.append(q)

        # Add the peaks to the PeaksWorkspace with dummy values for intensity,
        # Sigma, and HKL
        for q in qs:
            peak = ws.createPeak(q)
            peak.setIntensity(100)
            peak.setSigmaIntensity(10)
            peak.setHKL(1, 1, 1)
            ws.addPeak(peak)

        return ws
Пример #33
0
    def setUp(self):
        # Store an empty widget to parent all the views, and ensure they are deleted correctly
        self.obj = QWidget()

        setup_context_for_tests(self)
        self.context.instrument = 'EMU'
        self.load_file_view = BrowseFileWidgetView(self.obj)
        self.load_run_view = LoadRunWidgetView(self.obj)
        self.load_file_model = BrowseFileWidgetModel(self.loaded_data,
                                                     self.context)
        self.load_run_model = LoadRunWidgetModel(self.loaded_data,
                                                 self.context)

        self.presenter = LoadWidgetPresenter(
            LoadWidgetView(parent=self.obj,
                           load_file_view=self.load_file_view,
                           load_run_view=self.load_run_view),
            LoadWidgetModel(self.loaded_data, self.context))
        self.presenter.set_load_file_widget(
            BrowseFileWidgetPresenter(self.load_file_view,
                                      self.load_file_model))
        self.presenter.set_load_run_widget(
            LoadRunWidgetPresenter(self.load_run_view, self.load_run_model))

        self.filepath = FileFinder.findRuns('MUSR00022725.nxs')[0]

        self.load_patcher = mock.patch(
            'mantidqtinterfaces.Muon.GUI.Common.load_file_widget.model.load_utils.load_workspace_from_filename'
        )
        self.addCleanup(self.load_patcher.stop)
        self.load_mock = self.load_patcher.start()

        self.load_run_patcher = mock.patch(
            'mantidqtinterfaces.Muon.GUI.Common.load_run_widget.load_run_model.load_utils.load_workspace_from_filename'
        )
        self.addCleanup(self.load_run_patcher.stop)
        self.load_run_mock = self.load_run_patcher.start()

        self.mock_workspace = self.create_fake_workspace(1)
        self.mock_loading_from_browse(self.mock_workspace,
                                      r"C:\dir1\dir2\dir3\EMU0001234.nxs",
                                      1234)
        file_utils.get_current_run_filename = mock.Mock(
            return_value=r"C:\dir1\dir2\dir3\EMU0001234.nxs")

        self.presenter.load_file_widget._view.warning_popup = mock.MagicMock()
        self.presenter.load_run_widget._view.warning_popup = mock.MagicMock()

        self.popup_patcher = mock.patch(
            'mantidqtinterfaces.Muon.GUI.Common.thread_model.warning')
        self.addCleanup(self.popup_patcher.stop)
        self.popup_mock = self.popup_patcher.start()

        def setGroupAndPairsToEmptyList(grouping_context):
            grouping_context._groups = []
            grouping_context._pairs = []

        self.group_context.reset_group_and_pairs_to_default = mock.MagicMock(
            side_effect=setGroupAndPairsToEmptyList(self.group_context))
Пример #34
0
def find_full_file_path(file_name):
    """
    Gets the full path of a file name if it is available on the Mantid paths.

    :param file_name: the name of the file.
    :return: the full file path.
    """
    return FileFinder.getFullPath(file_name)
Пример #35
0
 def cleanup(self):
     Files = ["TOPAZ_3132.hkl",
     "TOPAZ_3132FFT.hkl"]
     for file in Files:
         absfile = FileFinder.getFullPath(file)
         if os.path.exists(absfile):
             os.remove(absfile)
     return True
Пример #36
0
def find_full_file_path(file_name):
    """
    Gets the full path of a file name if it is available on the Mantid paths.

    :param file_name: the name of the file.
    :return: the full file path.
    """
    return FileFinder.getFullPath(file_name)
Пример #37
0
 def _get_workspace(self, file_name):
     full_file_name = FileFinder.findRuns(file_name)[0]
     load_name = "Load"
     load_options = {"Filename": full_file_name,
                     "OutputWorkspace": EMPTY_NAME}
     load_alg = create_unmanaged_algorithm(load_name, **load_options)
     load_alg.execute()
     return load_alg.getProperty("OutputWorkspace").value
Пример #38
0
    def runTest(self):
        UseCompatibilityMode()
        SANS2D()
        MaskFile('MaskSANS2DReductionGUI.txt')
        SetEventSlices("0.0-451, 5-10")

        batch_file = FileFinder.getFullPath('sans2d_reduction_gui_batch.csv')
        BatchReduce(batch_file, '.nxs', saveAlgs={}, combineDet='rear')
Пример #39
0
def find_file(filename=None):
    """
    Calculates path of filename with the testing data. Path is determined in the platform independent way.

    :param filename: name of file to find
    :return: full path for the file with the testing data
    """
    from mantid.api import FileFinder
    return FileFinder.Instance().getFullPath(filename)
Пример #40
0
def do_cleanup():
    Files = ["PG3_9829.gsa",
    "PG3_9829.py",
    "PG3_9830.gsa",
    "PG3_9830.py"]
    for file in Files:
        absfile = FileFinder.getFullPath(file)
        if os.path.exists(absfile):
            os.remove(absfile)
    return True
Пример #41
0
def do_cleanup():
    Files = ["BioSANS_test_data_reduction.log",
             "BioSANS_test_data_Iq.xml",
             "BioSANS_test_data_Iq.txt",
             "BioSANS_test_data_Iqxy.dat"]
    for filename in Files:
        absfile = FileFinder.getFullPath(filename)
        if os.path.exists(absfile):
            os.remove(absfile)
    return True
    def test_browse_clicked_suceeds_if_table_in_ADS(self):
        filename = FileFinder.findRuns('MUSR00015196.nxs')[0]
        self.view.show_file_browser_and_return_selection = mock.MagicMock(return_value=[filename])
        self.model.check_dead_time_file_selection = mock.MagicMock(return_value=True)

        self.view.dead_time_browse_button.clicked.emit(True)

        self.assertEqual(self.view.dead_time_selector.currentIndex(), 2)
        self.view.warning_popup.assert_not_called()
        self.assertEqual(self.view.dead_time_file_selector.currentText(), 'MUSR00015196_deadTimes')
        self.gui_variable_observer.update.assert_called_once_with(self.gui_context.gui_variables_notifier, None)
Пример #43
0
    def runTest(self):
        UseCompatibilityMode()
        SANS2D()
        Set1D()
        Detector("rear-detector")
        MaskFile('MASKSANS2Doptions.091A')
        Gravity(True)

        csv_file = FileFinder.getFullPath('SANS2D_multiPeriodTests.csv')

        BatchReduce(csv_file, 'nxs', saveAlgs={})
        self.reduced = '5512_SANS2DBatch'
Пример #44
0
    def runTest(self):
        UseCompatibilityMode()
        SANS2D()
        Set1D()
        Detector("rear-detector")
        MaskFile('MASKSANS2Doptions.091A')
        Gravity(True)

        csv_file = FileFinder.getFullPath('SANS2D_periodTests.csv')

        BatchReduce(csv_file, 'nxs', plotresults=False, saveAlgs={'SaveCanSAS1D': 'xml', 'SaveNexus': 'nxs'})
        os.remove(os.path.join(config['defaultsave.directory'], '5512p7_SANS2DBatch.xml'))
Пример #45
0
    def __init__(self):
        ISISIndirectInelasticConvFit.__init__(self)
        self.sample = 'osi97935_graphite002_red.nxs'
        self.resolution = FileFinder.getFullPath('osi97935_graphite002_res.nxs')
        #ConvFit fit function
        self.func = 'name=LinearBackground,A0=0,A1=0;(composite=Convolution,FixResolution=true,NumDeriv=true;'\
                    'name=Resolution,Workspace=\"%s\";name=Lorentzian,Amplitude=2,PeakCentre=0,FWHM=0.05)' % self.resolution
        self.startx = -0.2
        self.endx = 0.2
        self.bg = 'Fit Linear'
        self.spectra_min = 0
        self.spectra_max = 41
        self.ties = False

        self.result_names = ['osi97935_graphite002_conv_1LFitL_s0_to_41_Result']
    def _run(self):
        '''Defines the workflow for the test'''
        self.tolerance = 1e-4
        LoadNexus(self.sample, OutputWorkspace=self.sample)
        LoadNexus(FileFinder.getFullPath(self.resolution), OutputWorkspace=self.resolution)

        convfitSeq_ws, params, fit_group = ConvolutionFitSequential(InputWorkspace=self.sample,
                                                                    Function=self.func,
                                                                    PassWSIndexToFunction=self.passWSIndexToFunction,
                                                                    StartX=self.startx,
                                                                    EndX=self.endx,
                                                                    SpecMin=self.spectra_min,
                                                                    SpecMax=self.spectra_max,
                                                                    PeakRadius=5)

        self.result_names = [convfitSeq_ws[0].name()]
Пример #47
0
    def __init__(self):
        ISISIndirectInelasticConvFit.__init__(self)
        self.sample = 'irs53664_graphite002_red.nxs'
        self.resolution = FileFinder.getFullPath('irs53664_graphite002_res.nxs')
        #ConvFit fit function
        self.func = 'name=LinearBackground,A0=0.060623,A1=0.001343;(composite=Convolution,FixResolution=true,NumDeriv=true;'\
                    'name=Resolution,Workspace=\"%s\";name=Lorentzian,Amplitude=1.033150,PeakCentre=-0.000841,FWHM=0.001576)'\
                    % (self.resolution)
        self.startx = -0.2
        self.endx = 0.2
        self.bg = 'Fit Linear'
        self.spectra_min = 0
        self.spectra_max = 50
        self.ties = False

        self.result_names = ['irs53664_graphite002_conv_1LFitL_s0_to_50_Result']
Пример #48
0
def find_sans_file(file_name):
    """
    Finds a SANS file.
    The file can be specified as:
    1. file.ext or  path1 path2 file.ext
    2. run number
    :param file_name: a file name or a run number.
    :return: the full path.
    """
    full_path = find_full_file_path(file_name)
    if not full_path:
        runs = FileFinder.findRuns(file_name)
        if runs:
            full_path = runs[0]
    if not full_path:
        raise RuntimeError("Trying to find the SANS file {0}, but cannot find it. Make sure that "
                           "the relevant paths are added.".format(file_name))
    return full_path
    def setUp(self):
        setup_context_for_tests(self)
        self.frequency_context = FrequencyContext(self.context)
        self.gui_variable_observer = Observer()
        self.gui_variable_observer.update = mock.MagicMock()
        self.gui_context.gui_variables_notifier.add_subscriber(self.gui_variable_observer)
        self.data_context.instrument = 'CHRONUS'
        self.gui_variable_observer = Observer()
        self.gui_variable_observer.update = mock.MagicMock()
        self.gui_context.gui_variables_notifier.add_subscriber(self.gui_variable_observer)

        filepath = FileFinder.findRuns('CHRONUS00003422.nxs')[0]

        load_result, run, filename = load_workspace_from_filename(filepath)

        self.loaded_data.add_data(workspace=load_result, run=[run], filename=filename, instrument='CHRONUS')
        self.data_context.current_runs = [[run]]
        self.context.update_current_data()
Пример #50
0
def do_cleanup():
    Files = ["PG3_9829.getn",
             "PG3_9829.gsa",
             "PG3_9829.py",
             'sum_PG3_9829.gsa',
             'sum_PG3_9829.py',
             "PG3_9830.gsa",
             "PG3_9830.py",
             "PG3_4844-1.dat",
             "PG3_4844.getn",
             "PG3_4844.gsa",
             "PG3_4844.py",
             "PG3_4866.gsa"]
    for filename in Files:
        absfile = FileFinder.getFullPath(filename)
        if os.path.exists(absfile):
            os.remove(absfile)
    return True
    def test_runinfo_correct(self):
        file_path = FileFinder.findRuns('MUSR00022725.nxs')[0]
        ws, run, filename = load_utils.load_workspace_from_filename(file_path)
        self.data_context._loaded_data.remove_data(run=run)
        self.data_context._loaded_data.add_data(run=[run], workspace=ws, filename=filename, instrument='MUSR')
        self.data_context.current_runs = [[22725]]
        self.context.update_current_data()
        test_pair = MuonPair('test_pair', 'top', 'bottom', alpha=0.75)
        self.group_context.add_pair(pair=test_pair)

        self.presenter.update_view_from_model()

        expected_string_list = ['Instrument:MUSR', 'Run:22725', 'Title:FeTeSeT=1F=100', 'Comment:FCfirstsample',
                                'Start:2009-03-24T04:18:58', 'End:2009-03-24T04:56:26', 'Counts(MEv):20.076704',
                                'GoodFrames:88540', 'CountsperGoodFrame:226.753',
                                'CountsperGoodFrameperdet:3.543', 'AverageTemperature(K):2.53386',
                                'SampleTemperature(K):1.0', 'SampleMagneticField(G):100.0']

        self.assertEqual(str(self.view.run_info_box.toPlainText()).replace(' ', '').splitlines(), expected_string_list)
Пример #52
0
    def runTest(self):
        UseCompatibilityMode()
        LOQ()
        Detector("main-detector-bank")
        csv_file = FileFinder.getFullPath('batch_input.csv')

        Set1D()
        MaskFile('MASK.094AA')
        Gravity(True)

        BatchReduce(csv_file, 'raw', plotresults=False, saveAlgs={'SaveCanSAS1D': 'xml', 'SaveNexus': 'nxs'})

        LoadNexus(Filename='54433sans.nxs', OutputWorkspace='result')
        Plus(LHSWorkspace='result', RHSWorkspace='99630sanotrans', OutputWorkspace= 'result')

        os.remove(os.path.join(config['defaultsave.directory'],'54433sans.nxs'))
        os.remove(os.path.join(config['defaultsave.directory'],'99630sanotrans.nxs'))
        os.remove(os.path.join(config['defaultsave.directory'],'54433sans.xml'))
        os.remove(os.path.join(config['defaultsave.directory'],'99630sanotrans.xml'))
Пример #53
0
    def runTest(self):
        UseCompatibilityMode()
        config['default.instrument'] = 'SANS2D'
        SANS2DTUBES()
        Set1D()
        Detector("rear-detector")
        # This contains two MASKFILE commands, each resulting in a seperate call to MaskDetectors.
        MaskFile('SANS2DTube_ZerroErrorFreeTest.txt')

        # Saves a file which produces an output file which does not contain any zero errors
        csv_file = FileFinder.getFullPath("SANS2DTUBES_ZeroErrorFree_batch.csv")
        save_alg = {"SaveNexus": "nxs"}
        BatchReduce(csv_file, 'nxs', saveAlgs=save_alg, plotresults=False, save_as_zero_error_free=True)
        DeleteWorkspace('zero_free_out')

        # The zero correction only occurs for the saved files. Stephen King mentioned that the
        # original workspaces should not be tampered with
        self._final_output = os.path.join(config['defaultsave.directory'], 'zero_free_out.nxs')
        self._final_workspace = 'ws'
        Load(Filename=self._final_output, OutputWorkspace=self._final_workspace)
Пример #54
0
    def runTest(self):
        UseCompatibilityMode()
        config['default.instrument'] = 'SANS2D'
        SANS2D()
        Set1D()
        Detector("rear-detector")
        # This contains two MASKFILE commands, each resulting in a separate call to MaskDetectors.
        MaskFile('MaskSANS2DReductionGUI_MaskFiles.txt')
        Gravity(True)

        # This does 2 separate reductions of the same data, but saving the result of each to a different workspace.
        csv_file = FileFinder.getFullPath("SANS2D_mask_batch.csv")
        BatchReduce(csv_file, 'nxs', plotresults=False)

        path1 = os.path.join(config['defaultsave.directory'], 'iteration_1.xml')
        path2 = os.path.join(config['defaultsave.directory'], 'iteration_2.xml')
        if os.path.exists(path1):
            os.remove(path1)
        if os.path.exists(path2):
            os.remove(path2)
Пример #55
0
    def setUp(self):
        AnalysisDataService.clear()
        self.filepath = FileFinder.findRuns('EMU00019489.nxs')[0]
        self.load_result, self.run_number, self.filename = load_workspace_from_filename(self.filepath)
        self.loaded_data = MuonLoadData()
        self.data_context = MuonDataContext(self.loaded_data)
        self.gui_context = MuonGuiContext()
        self.group_pair_context = MuonGroupPairContext()
        self.gui_context.update({'RebinType': 'None'})

        self.context = MuonContext(muon_data_context=self.data_context, muon_gui_context=self.gui_context, muon_group_context=self.group_pair_context)

        self.data_context.instrument = 'EMU'

        self.loaded_data.add_data(workspace=self.load_result, run=[self.run_number], filename=self.filename,
                                  instrument='EMU')
        self.data_context.current_runs = [[self.run_number]]
        self.data_context.update_current_data()
        self.group_pair_context.reset_group_and_pairs_to_default(self.load_result['OutputWorkspace'][0]._workspace,
                                                                 'EMU', '')
    def setUp(self):
        self._qapp = mock_widget.mockQapp()
        # Store an empty widget to parent all the views, and ensure they are deleted correctly
        self.obj = QtGui.QWidget()

        setup_context_for_tests(self)
        self.context.instrument = 'EMU'
        self.load_file_view = BrowseFileWidgetView(self.obj)
        self.load_run_view = LoadRunWidgetView(self.obj)
        self.load_file_model = BrowseFileWidgetModel(self.loaded_data, self.context)
        self.load_run_model = LoadRunWidgetModel(self.loaded_data, self.context)

        self.presenter = LoadWidgetPresenter(
            LoadWidgetView(parent=self.obj, load_file_view=self.load_file_view, load_run_view=self.load_run_view),
            LoadWidgetModel(self.loaded_data, self.context))
        self.presenter.set_load_file_widget(BrowseFileWidgetPresenter(self.load_file_view, self.load_file_model))
        self.presenter.set_load_run_widget(LoadRunWidgetPresenter(self.load_run_view, self.load_run_model))

        self.filepath = FileFinder.findRuns('MUSR00022725.nxs')[0]

        self.load_patcher = mock.patch('Muon.GUI.Common.load_file_widget.model.load_utils.load_workspace_from_filename')
        self.addCleanup(self.load_patcher.stop)
        self.load_mock = self.load_patcher.start()

        self.load_run_patcher = mock.patch(
            'Muon.GUI.Common.load_run_widget.load_run_model.load_utils.load_workspace_from_filename')
        self.addCleanup(self.load_run_patcher.stop)
        self.load_run_mock = self.load_run_patcher.start()

        self.mock_workspace = self.create_fake_workspace(1)
        self.mock_loading_from_browse(self.mock_workspace, "C:\dir1\dir2\dir3\EMU0001234.nxs", 1234)
        file_utils.get_current_run_filename = mock.Mock(return_value="C:\dir1\dir2\dir3\EMU0001234.nxs")

        self.presenter.load_file_widget._view.warning_popup = mock.MagicMock()
        self.presenter.load_run_widget._view.warning_popup = mock.MagicMock()

        self.popup_patcher = mock.patch('Muon.GUI.Common.thread_model.warning')
        self.addCleanup(self.popup_patcher.stop)
        self.popup_mock = self.popup_patcher.start()
Пример #57
0
    def findFile(self, instrument, runnumber):
        # start with run and check the five before it
        runIds = list(range(runnumber, runnumber-6, -1))
        # check for one after as well
        runIds.append(runnumber + 1)

        runIds = [str(runId) for runId in runIds if runId > 0]

        # prepend non-empty instrument name for FileFinder
        if len(instrument) > 0:
            runIds = ['%s_%s' % (instrument, runId) for runId in runIds]

        # look for a file
        for runId in runIds:
            self.log().information("Looking for '%s'" % runId)
            try:
                return FileFinder.findRuns(runId)[0]
            except RuntimeError:
                pass  # just keep looking

        # failed to find any is an error
        raise RuntimeError("Cannot find IPTS directory for '%s'"
                           % runnumber)
    def setUp(self):
        self._qapp = mock_widget.mockQapp()
        self.obj = QtGui.QWidget()
        ConfigService['default.instrument'] = 'MUSR'
        setup_context_for_tests(self)
        self.gui_context['RebinType'] = 'None'
        self.view = HomeGroupingWidgetView(self.obj)
        self.model = HomeGroupingWidgetModel(self.context)
        self.presenter = HomeGroupingWidgetPresenter(self.view, self.model)

        self.view.warning_popup = mock.MagicMock()
        self.view.instrument_changed_warning = mock.MagicMock(return_value=1)

        file_path = FileFinder.findRuns('MUSR00022725.nxs')[0]
        ws, run, filename = load_utils.load_workspace_from_filename(file_path)
        self.data_context._loaded_data.remove_data(run=run)
        self.data_context._loaded_data.add_data(run=[run], workspace=ws, filename=filename, instrument='MUSR')
        self.data_context.current_runs = [[22725]]

        self.context.update_current_data()
        test_pair = MuonPair('test_pair', 'top', 'bottom', alpha=0.75)
        self.group_context.add_pair(pair=test_pair)
        self.presenter.update_group_pair_list()