def validate(self): self.tolerance_is_rel_err = True self.tolerance = 1e-2 # this is neccesary due to appendspectra creating spectrum numbers of 0 self.disableChecking.append('SpectraMap') # fitted peaks table workspace is v sensitive to changes in input data so just validate X0 col if systemtesting.using_gsl_v1(): reffile = simple.LoadNexus( Filename="engggui_calibration_bank_cropped_gsl1.nxs") self.validateSingleColumn(mtd["cropped"].column("X0"), reffile.column("X0"), self.tolerance) return ("engg_calibration_banks_parameters", "engggui_calibration_cropped_parameters_gsl1.nxs", "Engg difc Zero Peaks Bank cropped", "engggui_difc_zero_peaks_bank_cropped_gsl1.nxs") else: reffile = simple.LoadNexus( Filename="engggui_calibration_bank_cropped.nxs") self.validateSingleColumn(mtd["cropped"].column("X0"), reffile.column("X0"), self.tolerance) return ("engg_calibration_banks_parameters", "engggui_calibration_bank_cropped_parameters.nxs", "Engg difc Zero Peaks Bank cropped", "engggui_difc_zero_peaks_bank_cropped.nxs")
def runTest(self): setup_mantid_paths() # Load Focused ws mantid.LoadNexus(Filename=total_scattering_input_file, OutputWorkspace='98533-Results-TOF-Grp') q_lims = np.array([2.5, 3, 4, 6, 7, 3.5, 5, 7, 11, 40]).reshape((2, 5)) self.pdf_output = run_total_scattering('98533', True, q_lims=q_lims)
def _obtain_focused_run(run_number, focus_file_path): """ Searches for the focused workspace to use (based on user specified run number) in the ADS and then the output directory. If unsuccessful, a ValueError exception is thrown. :param run_number: The run number to search for. :param focus_file_path: The expected file path for the focused file. :return: The focused workspace. """ # Try the ADS first to avoid undesired loading if mantid.mtd.doesExist('%s-ResultTOF' % run_number): focused_ws = mantid.mtd['%s-ResultTOF' % run_number] elif mantid.mtd.doesExist('%s-ResultD' % run_number): focused_ws = mantid.mtd['%s-ResultD' % run_number] else: # Check output directory print( 'No loaded focused files found. Searching in output directory...') try: focused_ws = mantid.LoadNexus( Filename=focus_file_path, OutputWorkspace='focused_ws').OutputWorkspace except ValueError: raise ValueError( "Could not find focused file for run number:%s\n" "Please ensure a focused file has been produced and is located in the output directory." % run_number) return focused_ws
def test_function_call_raises_ValueError_when_passed_args_with_invalid_values(self): # lhs code bug means we can't do this "self.assertRaises(simpleapi.LoadNexus, 'DoesNotExist')" --> ticket #4186 try: simpleapi.LoadNexus(Filename='DoesNotExist.nxs') self.fail("A ValueError was not thrown") except ValueError: pass
def setUp(self): """ Set up dependencies for one or more of the tests below. """ if not self.__class__._data_ws: self.__class__._data_ws = sapi.LoadNexus("ENGINX00228061.nxs", OutputWorkspace='ENGIN-X_test_ws') if not self.__class__._van_curves_ws: # Note the pre-calculated file instead of the too big vanadium run # self.__class__._van_ws = LoadNexus("ENGINX00236516.nxs", OutputWorkspace='ENGIN-X_test_vanadium_ws') self.__class__._van_curves_ws = sapi.LoadNexus(Filename= 'ENGINX_precalculated_vanadium_run000236516_bank_curves.nxs', OutputWorkspace='ENGIN-X_vanadium_curves_test_ws') self.__class__._van_integ_tbl = sapi.LoadNexus(Filename= 'ENGINX_precalculated_vanadium_run000236516_integration.nxs', OutputWorkspace='ENGIN-X_vanadium_integ_test_ws')
def test_function_call_raises_RuntimeError_when_passed_incorrect_args( self): try: simpleapi.LoadNexus(NotAProperty=1) self.fail("A RuntimeError was not thrown") except RuntimeError: pass
def _batched_run_focusing(instrument, perform_vanadium_norm, run_number_string, absorb, sample_details): read_ws_list = common.load_current_normalised_ws_list( run_number_string=run_number_string, instrument=instrument) run_details = instrument._get_run_details( run_number_string=run_number_string) vanadium_splines = None van = "van_{}".format(run_details.vanadium_run_numbers) if perform_vanadium_norm: if van not in mantid.mtd: vanadium_splines = mantid.LoadNexus( Filename=run_details.splined_vanadium_file_path, OutputWorkspace=van) else: vanadium_splines = mantid.mtd[van] output = None for ws in read_ws_list: output = _focus_one_ws(input_workspace=ws, run_number=run_number_string, instrument=instrument, perform_vanadium_norm=perform_vanadium_norm, absorb=absorb, sample_details=sample_details, vanadium_path=vanadium_splines) if instrument.get_instrument_prefix( ) == "PEARL" and vanadium_splines is not None: mantid.DeleteWorkspace(vanadium_splines.OutputWorkspace) return output
def _individual_run_focusing(instrument, perform_vanadium_norm, run_number, absorb, sample_details): # Load and process one by one run_numbers = common.generate_run_numbers(run_number_string=run_number) run_details = instrument._get_run_details(run_number_string=run_number) vanadium_splines = None van = "van_{}".format(run_details.vanadium_run_numbers) if perform_vanadium_norm: if van not in mantid.mtd: vanadium_splines = mantid.LoadNexus( Filename=run_details.splined_vanadium_file_path, OutputWorkspace=van) else: vanadium_splines = mantid.mtd[van] output = None for run in run_numbers: ws = common.load_current_normalised_ws_list(run_number_string=run, instrument=instrument) output = _focus_one_ws(input_workspace=ws[0], run_number=run, instrument=instrument, absorb=absorb, perform_vanadium_norm=perform_vanadium_norm, sample_details=sample_details, vanadium_path=vanadium_splines) return output
def _validate_wrapper(cls, focus_mode): cls.disableChecking.append('Instrument') cls.disableChecking.append('Sample') cls.disableChecking.append('SpectraMap') out_name = "PEARL_routines_fmode_" + focus_mode mantid.LoadNexus(Filename=DIRS[0] + "PEARL/Focus_Test/DataOut/PEARL92476_92479.nxs", OutputWorkspace=out_name) reference_file_name = "PEARL92476_92479_" + focus_mode + ".nxs" return out_name, reference_file_name
def _divide_by_vanadium_splines(spectra_list, spline_file_path): vanadium_ws_list = mantid.LoadNexus(Filename=spline_file_path) output_list = [] for data_ws, van_ws in zip(spectra_list, vanadium_ws_list[1:]): vanadium_ws = mantid.RebinToWorkspace(WorkspaceToRebin=van_ws, WorkspaceToMatch=data_ws) output_ws = mantid.Divide(LHSWorkspace=data_ws, RHSWorkspace=vanadium_ws, OutputWorkspace=data_ws) output_list.append(output_ws) common.remove_intermediate_workspace(vanadium_ws) return output_list
def _divide_by_vanadium_splines(spectra_list, spline_file_path): vanadium_splines = mantid.LoadNexus(Filename=spline_file_path) if hasattr(vanadium_splines, "OutputWorkspace"): # vanadium_splines is a group vanadium_splines = vanadium_splines.OutputWorkspace num_splines = len(vanadium_splines) num_spectra = len(spectra_list) if num_splines != num_spectra: raise RuntimeError("Mismatch between number of banks in vanadium and number of banks in workspace to focus" "\nThere are {} banks for vanadium but {} for the run".format(num_splines, num_spectra)) output_list = [_divide_one_spectrum_by_spline(data_ws, van_ws) for data_ws, van_ws in zip(spectra_list, vanadium_splines)] return output_list output_list = [_divide_one_spectrum_by_spline(spectra_list[0], vanadium_splines)] common.remove_intermediate_workspace(vanadium_splines) return output_list
def parse_nxs(file_name): name, ext = os.path.splitext(file_name) if ext != '.nxs': print('Wrong file!', ext) return -1 ws = ms.LoadNexus(file_name) xs = ws.readX(0) ys = ws.readY(0) es = ws.readE(0) data_template = '{0} {1} {2}\n' lines = ['# X Y E\n', '\n'] lines += [ data_template.format(x, y, e) for x, y, e in itertools.izip(xs, ys, es) ] with open(name + '.txt', 'w') as f: f.writelines(lines)
def _batched_run_focusing(instrument, perform_vanadium_norm, run_number_string, absorb, sample_details): read_ws_list = common.load_current_normalised_ws_list( run_number_string=run_number_string, instrument=instrument) run_details = instrument._get_run_details( run_number_string=run_number_string) vanadium_splines = None if perform_vanadium_norm: vanadium_splines = mantid.LoadNexus( Filename=run_details.splined_vanadium_file_path) output = None for ws in read_ws_list: output = _focus_one_ws(input_workspace=ws, run_number=run_number_string, instrument=instrument, perform_vanadium_norm=perform_vanadium_norm, absorb=absorb, sample_details=sample_details, vanadium_path=vanadium_splines) return output
def _focus_load(alg_range, focused_ws, input_file_paths, instrument, van_norm): processed_spectra = [] for index in range(0, alg_range): if van_norm: vanadium_ws = mantid.LoadNexus( Filename=input_file_paths["vanadium"], EntryNumber=index + 1) van_rebinned = mantid.Rebin( InputWorkspace=vanadium_ws, Params=instrument._get_focus_tof_binning()) processed_spectra.append( calc_calibration_with_vanadium(focused_ws, index, van_rebinned, instrument)) remove_intermediate_workspace(vanadium_ws) remove_intermediate_workspace(van_rebinned) else: processed_spectra.append( calc_calibration_without_vanadium(focused_ws, index, instrument)) return processed_spectra
def runTest(self): setup_mantid_paths() # Load Focused ws mantid.LoadNexus(Filename=total_scattering_input_file, OutputWorkspace='98533-ResultTOF') self.pdf_output = run_total_scattering('98533', False)
def runTest(self): # Load Focused ws mantid.LoadNexus(Filename=total_scattering_input_file, OutputWorkspace='98533-Results-TOF-Grp') self.pdf_output = run_total_scattering('98533', False)
def _focus_one_ws(input_workspace, run_number, instrument, perform_vanadium_norm, absorb, sample_details, vanadium_path, empty_can_subtraction_method, paalman_pings_events_per_point=None): run_details = instrument._get_run_details(run_number_string=run_number) if perform_vanadium_norm: _test_splined_vanadium_exists(instrument, run_details) # Subtract empty instrument runs, as long as this run isn't an empty, user hasn't turned empty subtraction off, or # The user has not supplied a sample empty is_run_empty = common.runs_overlap(run_number, run_details.empty_inst_runs) summed_empty = None if not is_run_empty and instrument.should_subtract_empty_inst( ) and not run_details.sample_empty: if os.path.isfile(run_details.summed_empty_inst_file_path): logger.warning('Pre-summed empty instrument workspace found at ' + run_details.summed_empty_inst_file_path) summed_empty = mantid.LoadNexus( Filename=run_details.summed_empty_inst_file_path) else: summed_empty = common.generate_summed_runs( empty_sample_ws_string=run_details.empty_inst_runs, instrument=instrument) elif run_details.sample_empty: scale_factor = 1.0 if empty_can_subtraction_method != 'PaalmanPings': scale_factor = instrument._inst_settings.sample_empty_scale # Subtract a sample empty if specified ie empty can summed_empty = common.generate_summed_runs( empty_sample_ws_string=run_details.sample_empty, instrument=instrument, scale_factor=scale_factor) if absorb and empty_can_subtraction_method == 'PaalmanPings': if run_details.sample_empty: # need summed_empty including container input_workspace = instrument._apply_paalmanpings_absorb_and_subtract_empty( workspace=input_workspace, summed_empty=summed_empty, sample_details=sample_details, paalman_pings_events_per_point=paalman_pings_events_per_point) # Crop to largest acceptable TOF range input_workspace = instrument._crop_raw_to_expected_tof_range( ws_to_crop=input_workspace) else: raise TypeError( "The PaalmanPings absorption method requires 'sample_empty' to be supplied." ) else: if summed_empty: input_workspace = common.subtract_summed_runs( ws_to_correct=input_workspace, empty_sample=summed_empty) # Crop to largest acceptable TOF range input_workspace = instrument._crop_raw_to_expected_tof_range( ws_to_crop=input_workspace) if absorb: input_workspace = instrument._apply_absorb_corrections( run_details=run_details, ws_to_correct=input_workspace) else: # Set sample material if specified by the user if sample_details is not None: mantid.SetSample( InputWorkspace=input_workspace, Geometry=sample_details.generate_sample_geometry(), Material=sample_details.generate_sample_material()) # Align mantid.ApplyDiffCal(InstrumentWorkspace=input_workspace, CalibrationFile=run_details.offset_file_path) aligned_ws = mantid.ConvertUnits(InputWorkspace=input_workspace, Target="dSpacing") solid_angle = instrument.get_solid_angle_corrections( run_details.vanadium_run_numbers, run_details) if solid_angle: aligned_ws = mantid.Divide(LHSWorkspace=aligned_ws, RHSWorkspace=solid_angle) mantid.DeleteWorkspace(solid_angle) # Focus the spectra into banks focused_ws = mantid.DiffractionFocussing( InputWorkspace=aligned_ws, GroupingFileName=run_details.grouping_file_path) instrument.apply_calibration_to_focused_data(focused_ws) calibrated_spectra = _apply_vanadium_corrections( instrument=instrument, input_workspace=focused_ws, perform_vanadium_norm=perform_vanadium_norm, vanadium_splines=vanadium_path) output_spectra = instrument._crop_banks_to_user_tof(calibrated_spectra) bin_widths = instrument._get_instrument_bin_widths() if bin_widths: # Reduce the bin width if required on this instrument output_spectra = common.rebin_workspace_list( workspace_list=output_spectra, bin_width_list=bin_widths) # Output d_spacing_group, tof_group = instrument._output_focused_ws( output_spectra, run_details=run_details) common.keep_single_ws_unit(d_spacing_group=d_spacing_group, tof_group=tof_group, unit_to_keep=instrument._get_unit_to_keep()) # Tidy workspaces from Mantid common.remove_intermediate_workspace(input_workspace) common.remove_intermediate_workspace(aligned_ws) common.remove_intermediate_workspace(focused_ws) common.remove_intermediate_workspace(output_spectra) return d_spacing_group
def _create_van(instrument, van, empty, output_van_file_name, num_of_splines=60, absorb=True, gen_absorb=False): cycle_information = instrument._get_cycle_information(van) input_van_ws = _read_ws(number=van, instrument=instrument) input_empty_ws = _read_ws(number=empty, instrument=instrument) corrected_van_ws = mantid.Minus(LHSWorkspace=input_van_ws, RHSWorkspace=input_empty_ws) remove_intermediate_workspace(input_empty_ws) remove_intermediate_workspace(input_van_ws) calibration_full_paths = instrument._get_calibration_full_paths( cycle=cycle_information["cycle"]) tof_binning = instrument._get_create_van_tof_binning() if absorb: corrected_van_ws = _apply_absorb_corrections(calibration_full_paths, corrected_van_ws, gen_absorb) corrected_van_ws = mantid.ConvertUnits(InputWorkspace=corrected_van_ws, Target="TOF") corrected_van_ws = mantid.Rebin(InputWorkspace=corrected_van_ws, Params=tof_binning["1"]) corrected_van_ws = mantid.AlignDetectors( InputWorkspace=corrected_van_ws, CalibrationFile=calibration_full_paths["calibration"]) focused_van_file = mantid.DiffractionFocussing( InputWorkspace=corrected_van_ws, GroupingFileName=calibration_full_paths["grouping"]) focused_van_file = mantid.ConvertUnits(InputWorkspace=focused_van_file, Target="TOF") focused_van_file = mantid.Rebin(InputWorkspace=focused_van_file, Params=tof_binning["2"]) focused_van_file = mantid.ConvertUnits(InputWorkspace=focused_van_file, Target="dSpacing") remove_intermediate_workspace(corrected_van_ws) splined_ws_list = instrument._spline_background( focused_van_file, num_of_splines, cycle_information["instrument_version"]) if instrument._PEARL_use_full_path(): out_van_file_path = output_van_file_name else: out_van_file_path = instrument.calibration_dir + output_van_file_name append = False for ws in splined_ws_list: mantid.SaveNexus(Filename=out_van_file_path, InputWorkspace=ws, Append=append) remove_intermediate_workspace(ws) append = True mantid.LoadNexus(Filename=out_van_file_path, OutputWorkspace="Van_data")
def _load_van_absorb_corr(calibration_full_paths): absorption_ws = mantid.LoadNexus( Filename=calibration_full_paths["vanadium_absorption"]) return absorption_ws