def PyExec(self): # get parameter values wsString = self.getPropertyValue("InputWorkspace").strip() #internal values wsOutput = "__OutputWorkspace" wsTemp = "__Sort_temp" #get the workspace list wsNames = [] for wsName in wsString.split(","): ws = mtd[wsName.strip()] if isinstance(ws, WorkspaceGroup): wsNames.extend(ws.getNames()) else: wsNames.append(wsName) if wsOutput in mtd: ms.DeleteWorkspace(Workspace=wsOutput) sortStat = [] for wsName in wsNames: if "qvectors" in wsName: #extract the spectrum ws = mtd[wsName.strip()] for s in range(0, ws.getNumberHistograms()): y_s = ws.readY(s) stuple = (self.GetXValue(y_s), s) sortStat.append(stuple) sortStat.sort() if len(sortStat) == 0: raise RuntimeError("Cannot find file with qvectors, aborting") #sort spectra using norm of q for wsName in wsNames: ws = mtd[wsName.strip()] yUnit = ws.getAxis(1).getUnit().unitID() transposed = False if ws.getNumberHistograms() < len(sortStat): ms.Transpose(InputWorkspace=wsName, OutputWorkspace=wsName) transposed = True for norm, spec in sortStat: ms.ExtractSingleSpectrum(InputWorkspace=wsName, OutputWorkspace=wsTemp, WorkspaceIndex=spec) if wsOutput in mtd: ms.ConjoinWorkspaces(InputWorkspace1=wsOutput,InputWorkspace2=wsTemp,CheckOverlapping=False) if wsTemp in mtd: ms.DeleteWorkspace(Workspace=wsTemp) else: ms.RenameWorkspace(InputWorkspace=wsTemp, OutputWorkspace=wsOutput) #put norm as y value and copy units from input loopIndex = 0 wsOut = mtd[wsOutput] for norm, spec in sortStat: wsOut.getSpectrum(loopIndex).setSpectrumNo(int(norm*1000)) loopIndex = loopIndex + 1 if len(yUnit) > 0: wsOut.getAxis(1).setUnit(yUnit) if transposed: ms.Transpose(InputWorkspace=wsOutput, OutputWorkspace=wsOutput) ms.RenameWorkspace(InputWorkspace=wsOutput, OutputWorkspace=wsName)
def rebin_workspace(self, input_ws, binning_param_list, output_ws_name): """ rebin input workspace with user specified binning parameters :param input_ws: :param binning_param_list: :param output_ws_name: :return: """ if binning_param_list is None: # no re-binning is required: clone the output workspace output_workspace = api.CloneWorkspace( InputWorkspace=input_ws, OutputWorkspace=output_ws_name) else: # rebin input workspace processed_single_spec_ws_list = list() for ws_index in range(input_ws.getNumberHistograms()): # rebin on each temp_out_name = output_ws_name + '_' + str(ws_index) processed_single_spec_ws_list.append(temp_out_name) # extract a spectrum out api.ExtractSpectra(input_ws, WorkspaceIndexList=[ws_index], OutputWorkspace=temp_out_name) # get binning parameter bin_params = binning_param_list[ws_index] if bin_params is None: continue # rebin # check if len(bin_params) % 2 == 0: # odd number and cannot be binning parameters raise RuntimeError( 'Binning parameter {0} cannot be accepted.'.format( bin_params)) api.Rebin(InputWorkspace=temp_out_name, OutputWorkspace=temp_out_name, Params=bin_params, PreserveEvents=True) rebinned_ws = AnalysisDataService.retrieve(temp_out_name) self.log().warning( 'Rebinnd workspace Size(x) = {0}, Size(y) = {1}'.format( len(rebinned_ws.readX(0)), len(rebinned_ws.readY(0)))) # Upon this point, the workspace is still HistogramData. # Check whether it is necessary to reset the X-values to reference TOF from VDRIVE temp_out_ws = AnalysisDataService.retrieve(temp_out_name) if len(bin_params) == 2 * len(temp_out_ws.readX(0)) - 1: reset_bins = True else: reset_bins = False # convert to point data api.ConvertToPointData(InputWorkspace=temp_out_name, OutputWorkspace=temp_out_name) # align the bin boundaries if necessary temp_out_ws = AnalysisDataService.retrieve(temp_out_name) if reset_bins: # good to align: for tof_i in range(len(temp_out_ws.readX(0))): temp_out_ws.dataX(0)[tof_i] = int( bin_params[2 * tof_i] * 10) / 10. # END-FOR (tof-i) # END-IF (align) # END-FOR # merge together api.RenameWorkspace( InputWorkspace=processed_single_spec_ws_list[0], OutputWorkspace=output_ws_name) for ws_index in range(1, len(processed_single_spec_ws_list)): api.ConjoinWorkspaces( InputWorkspace1=output_ws_name, InputWorkspace2=processed_single_spec_ws_list[ws_index]) # END-FOR output_workspace = AnalysisDataService.retrieve(output_ws_name) # END-IF-ELSE return output_workspace
def fit_tof_iteration(sample_data, container_data, runs, flags): """ Performs a single iterations of the time of flight corrections and fitting workflow. :param sample_data: Loaded sample data workspaces :param container_data: Loaded container data workspaces :param runs: A string specifying the runs to process :param flags: A dictionary of flags to control the processing :return: Tuple of (workspace group name, pre correction fit parameters, final fit parameters, chi^2 values) """ # Transform inputs into something the algorithm can understand if isinstance(flags['masses'][0], list): mass_values = _create_profile_strs_and_mass_list( copy.deepcopy(flags['masses'][0]))[0] profiles_strs = [] for mass_spec in flags['masses']: profiles_strs.append( _create_profile_strs_and_mass_list(mass_spec)[1]) else: mass_values, profiles_strs = _create_profile_strs_and_mass_list( flags['masses']) background_str = _create_background_str(flags.get('background', None)) intensity_constraints = _create_intensity_constraint_str( flags['intensity_constraints']) ties = _create_user_defined_ties_str(flags['masses']) num_spec = sample_data.getNumberHistograms() pre_correct_pars_workspace = None pars_workspace = None fit_workspace = None max_fit_iterations = flags.get('max_fit_iterations', 5000) output_groups = [] chi2_values = [] data_workspaces = [] result_workspaces = [] group_name = runs + '_result' for index in range(num_spec): if isinstance(profiles_strs, list): profiles = profiles_strs[index] else: profiles = profiles_strs suffix = _create_fit_workspace_suffix(index, sample_data, flags['fit_mode'], flags['spectra'], flags.get('iteration', None)) # Corrections corrections_args = dict() # Need to do a fit first to obtain the parameter table pre_correction_pars_name = runs + "_params_pre_correction" + suffix corrections_fit_name = "__vesuvio_corrections_fit" ms.VesuvioTOFFit(InputWorkspace=sample_data, WorkspaceIndex=index, Masses=mass_values, MassProfiles=profiles, Background=background_str, IntensityConstraints=intensity_constraints, Ties=ties, OutputWorkspace=corrections_fit_name, FitParameters=pre_correction_pars_name, MaxIterations=max_fit_iterations, Minimizer=flags['fit_minimizer']) ms.DeleteWorkspace(corrections_fit_name) corrections_args['FitParameters'] = pre_correction_pars_name # Add the multiple scattering arguments corrections_args.update(flags['ms_flags']) corrected_data_name = runs + "_tof_corrected" + suffix linear_correction_fit_params_name = runs + "_correction_fit_scale" + suffix if flags.get('output_verbose_corrections', False): corrections_args[ "CorrectionWorkspaces"] = runs + "_correction" + suffix corrections_args[ "CorrectedWorkspaces"] = runs + "_corrected" + suffix if container_data is not None: corrections_args["ContainerWorkspace"] = container_data ms.VesuvioCorrections( InputWorkspace=sample_data, OutputWorkspace=corrected_data_name, LinearFitResult=linear_correction_fit_params_name, WorkspaceIndex=index, GammaBackground=flags.get('gamma_correct', False), Masses=mass_values, MassProfiles=profiles, IntensityConstraints=intensity_constraints, MultipleScattering=True, GammaBackgroundScale=flags.get('fixed_gamma_scaling', 0.0), ContainerScale=flags.get('fixed_container_scaling', 0.0), **corrections_args) # Final fit fit_ws_name = runs + "_data" + suffix pars_name = runs + "_params" + suffix fit_result = ms.VesuvioTOFFit( InputWorkspace=corrected_data_name, WorkspaceIndex=0, Masses=mass_values, MassProfiles=profiles, Background=background_str, IntensityConstraints=intensity_constraints, Ties=ties, OutputWorkspace=fit_ws_name, FitParameters=pars_name, MaxIterations=max_fit_iterations, Minimizer=flags['fit_minimizer']) chi2_values.append(fit_result[-1]) ms.DeleteWorkspace(corrected_data_name) # Process parameter tables if pre_correct_pars_workspace is None: pre_correct_pars_workspace = _create_param_workspace( num_spec, mtd[pre_correction_pars_name]) if pars_workspace is None: pars_workspace = _create_param_workspace(num_spec, mtd[pars_name]) if fit_workspace is None: fit_workspace = _create_param_workspace( num_spec, mtd[linear_correction_fit_params_name]) spec_num_str = str(sample_data.getSpectrum(index).getSpectrumNo()) current_spec = 'spectrum_' + spec_num_str _update_fit_params(pre_correct_pars_workspace, index, mtd[pre_correction_pars_name], current_spec) _update_fit_params(pars_workspace, index, mtd[pars_name], current_spec) _update_fit_params(fit_workspace, index, mtd[linear_correction_fit_params_name], current_spec) ms.DeleteWorkspace(pre_correction_pars_name) ms.DeleteWorkspace(pars_name) ms.DeleteWorkspace(linear_correction_fit_params_name) # Process spectrum group # Note the ordering of operations here gives the order in the WorkspaceGroup output_workspaces = [] data_workspaces.append(fit_ws_name) if flags.get('output_verbose_corrections', False): output_workspaces += mtd[ corrections_args["CorrectionWorkspaces"]].getNames() output_workspaces += mtd[ corrections_args["CorrectedWorkspaces"]].getNames() ms.UnGroupWorkspace(corrections_args["CorrectionWorkspaces"]) ms.UnGroupWorkspace(corrections_args["CorrectedWorkspaces"]) for workspace in output_workspaces: group_name = runs + '_iteration_' + str( flags.get('iteration', None)) name = group_name + '_' + workspace.split( '_')[1] + '_' + workspace.split('_')[-1] result_workspaces.append(name) if index == 0: ms.RenameWorkspace(InputWorkspace=workspace, OutputWorkspace=name) else: ms.ConjoinWorkspaces(InputWorkspace1=name, InputWorkspace2=workspace) # Output the parameter workspaces params_pre_corr = runs + "_params_pre_correction_iteration_" + str( flags['iteration']) params_name = runs + "_params_iteration_" + str(flags['iteration']) fit_name = runs + "_correction_fit_scale_iteration_" + str( flags['iteration']) AnalysisDataService.Instance().addOrReplace( params_pre_corr, pre_correct_pars_workspace) AnalysisDataService.Instance().addOrReplace(params_name, pars_workspace) AnalysisDataService.Instance().addOrReplace(fit_name, fit_workspace) if result_workspaces: output_groups.append( ms.GroupWorkspaces(InputWorkspaces=result_workspaces, OutputWorkspace=group_name)) if data_workspaces: output_groups.append( ms.GroupWorkspaces(InputWorkspaces=data_workspaces, OutputWorkspace=group_name + '_data')) else: output_groups.append(fit_ws_name) if len(output_groups) > 1: result_ws = output_groups else: result_ws = output_groups[0] return result_ws, pre_correct_pars_workspace, pars_workspace, chi2_values