def test_save_file_check_contents(self): save_file(self.wksp, self.out_ascii) out_wksp = LoadAscii(self.out_ascii, Separator='Space') out_wksp = ConvertToHistogram(out_wksp) self.assertEqual(out_wksp.blocksize(), self.wksp.blocksize()) self.assertEqual(out_wksp.getNumberHistograms(), self.wksp.getNumberHistograms()) self.assertTrue(np.allclose(out_wksp.getAxis(0).extractValues(), self.wksp.getAxis(0).extractValues()) )
def merge_and_crop_workspaces(self, workspaces): """ where workspaces is a tuple of form: (filepath, ws name) """ workspace_name = self.getPropertyValue('GroupWorkspace') # detectors is a dictionary of {detector_name : [names_of_workspaces]} detectors = { f"{workspace_name}; Detector {x}": [] for x in range(1, 5) } # fill dictionary for workspace in workspaces: detector_number = workspace[0] detectors[f"{workspace_name}; Detector {detector_number}"].append( workspace) # initialise a group workspace overall_ws = WorkspaceGroup() # merge each workspace list in detectors into a single workspace for detector, workspace_list in detectors.items(): if workspace_list: # sort workspace list according to type_index sorted_workspace_list = [None] * NUM_FILES_PER_DETECTOR # sort workspace list according to type_index for workspace in workspace_list: data_type = workspace.rsplit("_")[1] sorted_workspace_list[SPECTRUM_INDEX[data_type] - 1] = workspace workspace_list = sorted_workspace_list # create merged workspace merged_ws = self.create_merged_workspace(workspace_list) ConvertToHistogram(InputWorkspace=merged_ws, OutputWorkspace=detector) minX, maxX = [], [] ws = AnalysisDataService.retrieve(detector) for i in range(ws.getNumberHistograms()): xdata = ws.readX(i) minX.append(xdata[0]) if i == 2: maxX.append(xdata[-1]) else: maxX.append(xdata[-1] - 1) CropWorkspaceRagged(InputWorkspace=detector, OutputWorkspace=detector, xmin=minX, xmax=maxX) overall_ws.addWorkspace(AnalysisDataService.retrieve(detector)) self.setProperty("GroupWorkspace", overall_ws)
def TotalScatteringReduction(config=None): facility = config['Facility'] title = config['Title'] instr = config['Instrument'] # Get an instance to Mantid's logger log = Logger("TotalScatteringReduction") # Get sample info sample = get_sample(config) sam_mass_density = sample.get('MassDensity', None) sam_packing_fraction = sample.get('PackingFraction', None) sam_geometry = sample.get('Geometry', None) sam_material = sample.get('Material', None) sam_geo_dict = { 'Shape': 'Cylinder', 'Radius': config['Sample']['Geometry']['Radius'], 'Height': config['Sample']['Geometry']['Height'] } sam_mat_dict = { 'ChemicalFormula': sam_material, 'SampleMassDensity': sam_mass_density } if 'Environment' in config: sam_env_dict = { 'Name': config['Environment']['Name'], 'Container': config['Environment']['Container'] } else: sam_env_dict = {'Name': 'InAir', 'Container': 'PAC06'} # Get normalization info van = get_normalization(config) van_mass_density = van.get('MassDensity', None) van_packing_fraction = van.get('PackingFraction', 1.0) van_geometry = van.get('Geometry', None) van_material = van.get('Material', 'V') van_geo_dict = { 'Shape': 'Cylinder', 'Radius': config['Normalization']['Geometry']['Radius'], 'Height': config['Normalization']['Geometry']['Height'] } van_mat_dict = { 'ChemicalFormula': van_material, 'SampleMassDensity': van_mass_density } # Get calibration, characterization, and other settings merging = config['Merging'] binning = merging['QBinning'] characterizations = merging.get('Characterizations', None) # Grouping grouping = merging.get('Grouping', None) cache_dir = config.get("CacheDir", os.path.abspath('.')) OutputDir = config.get("OutputDir", os.path.abspath('.')) # Create Nexus file basenames sample['Runs'] = expand_ints(sample['Runs']) sample['Background']['Runs'] = expand_ints(sample['Background'].get( 'Runs', None)) ''' Currently not implemented: # wkspIndices = merging.get('SumBanks', None) # high_q_linear_fit_range = config['HighQLinearFitRange'] POWGEN options not used #alignAndFocusArgs['RemovePromptPulseWidth'] = 50 # alignAndFocusArgs['CompressTolerance'] use defaults # alignAndFocusArgs['UnwrapRef'] POWGEN option # alignAndFocusArgs['LowResRef'] POWGEN option # alignAndFocusArgs['LowResSpectrumOffset'] POWGEN option How much of each bank gets merged has info here in the form of # {"ID", "Qmin", "QMax"} # alignAndFocusArgs['CropWavelengthMin'] from characterizations file # alignAndFocusArgs['CropWavelengthMax'] from characterizations file ''' if facility == 'SNS': facility_file_format = '%s_%d' else: facility_file_format = '%s%d' sam_scans = ','.join( [facility_file_format % (instr, num) for num in sample['Runs']]) container_scans = ','.join([ facility_file_format % (instr, num) for num in sample['Background']["Runs"] ]) container_bg = None if "Background" in sample['Background']: sample['Background']['Background']['Runs'] = expand_ints( sample['Background']['Background']['Runs']) container_bg = ','.join([ facility_file_format % (instr, num) for num in sample['Background']['Background']['Runs'] ]) if len(container_bg) == 0: container_bg = None van['Runs'] = expand_ints(van['Runs']) van_scans = ','.join( [facility_file_format % (instr, num) for num in van['Runs']]) van_bg_scans = None if 'Background' in van: van_bg_scans = van['Background']['Runs'] van_bg_scans = expand_ints(van_bg_scans) van_bg_scans = ','.join( [facility_file_format % (instr, num) for num in van_bg_scans]) # Override Nexus file basename with Filenames if present if "Filenames" in sample: sam_scans = ','.join(sample["Filenames"]) if "Filenames" in sample['Background']: container_scans = ','.join(sample['Background']["Filenames"]) if "Background" in sample['Background']: if "Filenames" in sample['Background']['Background']: container_bg = ','.join( sample['Background']['Background']['Filenames']) if "Filenames" in van: van_scans = ','.join(van["Filenames"]) if "Background" in van: if "Filenames" in van['Background']: van_bg_scans = ','.join(van['Background']["Filenames"]) # Output nexus filename nexus_filename = title + '.nxs' try: os.remove(nexus_filename) except OSError: pass # Get sample corrections sam_abs_corr = sample.get("AbsorptionCorrection", None) sam_ms_corr = sample.get("MultipleScatteringCorrection", None) sam_inelastic_corr = SetInelasticCorrection( sample.get('InelasticCorrection', None)) # Warn about having absorption correction and multiple scat correction set if sam_abs_corr and sam_ms_corr: log.warning(MS_AND_ABS_CORR_WARNING) # Compute the absorption correction on the sample if it was provided sam_abs_ws = '' con_abs_ws = '' if sam_abs_corr: msg = "Applying '{}' absorption correction to sample" log.notice(msg.format(sam_abs_corr["Type"])) sam_abs_ws, con_abs_ws = create_absorption_wksp( sam_scans, sam_abs_corr["Type"], sam_geo_dict, sam_mat_dict, sam_env_dict, **config) # Get vanadium corrections van_mass_density = van.get('MassDensity', van_mass_density) van_packing_fraction = van.get('PackingFraction', van_packing_fraction) van_abs_corr = van.get("AbsorptionCorrection", {"Type": None}) van_ms_corr = van.get("MultipleScatteringCorrection", {"Type": None}) van_inelastic_corr = SetInelasticCorrection( van.get('InelasticCorrection', None)) # Warn about having absorption correction and multiple scat correction set if van_abs_corr["Type"] and van_ms_corr["Type"]: log.warning(MS_AND_ABS_CORR_WARNING) # Compute the absorption correction for the vanadium if provided van_abs_corr_ws = '' if van_abs_corr: msg = "Applying '{}' absorption correction to vanadium" log.notice(msg.format(van_abs_corr["Type"])) van_abs_corr_ws, van_con_ws = create_absorption_wksp( van_scans, van_abs_corr["Type"], van_geo_dict, van_mat_dict, **config) alignAndFocusArgs = dict() alignAndFocusArgs['CalFilename'] = config['Calibration']['Filename'] # alignAndFocusArgs['GroupFilename'] don't use # alignAndFocusArgs['Params'] = "0.,0.02,40." alignAndFocusArgs['ResampleX'] = -6000 alignAndFocusArgs['Dspacing'] = False alignAndFocusArgs['PreserveEvents'] = False alignAndFocusArgs['MaxChunkSize'] = 8 alignAndFocusArgs['CacheDir'] = os.path.abspath(cache_dir) # Get any additional AlignAndFocusArgs from JSON input if "AlignAndFocusArgs" in config: otherArgs = config["AlignAndFocusArgs"] alignAndFocusArgs.update(otherArgs) # Setup grouping output_grouping = False grp_wksp = "wksp_output_group" if grouping: if 'Initial' in grouping: if grouping['Initial'] and not grouping['Initial'] == u'': alignAndFocusArgs['GroupFilename'] = grouping['Initial'] if 'Output' in grouping: if grouping['Output'] and not grouping['Output'] == u'': output_grouping = True LoadDetectorsGroupingFile(InputFile=grouping['Output'], OutputWorkspace=grp_wksp) # If no output grouping specified, create it with Calibration Grouping if not output_grouping: LoadDiffCal(alignAndFocusArgs['CalFilename'], InstrumentName=instr, WorkspaceName=grp_wksp.replace('_group', ''), MakeGroupingWorkspace=True, MakeCalWorkspace=False, MakeMaskWorkspace=False) # Setup the 6 bank method if no grouping specified if not grouping: CreateGroupingWorkspace(InstrumentName=instr, GroupDetectorsBy='Group', OutputWorkspace=grp_wksp) alignAndFocusArgs['GroupingWorkspace'] = grp_wksp # TODO take out the RecalculatePCharge in the future once tested # Load Sample print("#-----------------------------------#") print("# Sample") print("#-----------------------------------#") sam_wksp = load('sample', sam_scans, sam_geometry, sam_material, sam_mass_density, sam_abs_ws, **alignAndFocusArgs) sample_title = "sample_and_container" save_banks(InputWorkspace=sam_wksp, Filename=nexus_filename, Title=sample_title, OutputDir=OutputDir, GroupingWorkspace=grp_wksp, Binning=binning) sam_molecular_mass = mtd[sam_wksp].sample().getMaterial( ).relativeMolecularMass() natoms = getNumberAtoms(sam_packing_fraction, sam_mass_density, sam_molecular_mass, Geometry=sam_geometry) # Load Sample Container print("#-----------------------------------#") print("# Sample Container") print("#-----------------------------------#") container = load('container', container_scans, absorption_wksp=con_abs_ws, **alignAndFocusArgs) save_banks(InputWorkspace=container, Filename=nexus_filename, Title=container, OutputDir=OutputDir, GroupingWorkspace=grp_wksp, Binning=binning) # Load Sample Container Background if container_bg is not None: print("#-----------------------------------#") print("# Sample Container's Background") print("#-----------------------------------#") container_bg = load('container_background', container_bg, **alignAndFocusArgs) save_banks(InputWorkspace=container_bg, Filename=nexus_filename, Title=container_bg, OutputDir=OutputDir, GroupingWorkspace=grp_wksp, Binning=binning) # Load Vanadium print("#-----------------------------------#") print("# Vanadium") print("#-----------------------------------#") van_wksp = load('vanadium', van_scans, van_geometry, van_material, van_mass_density, van_abs_corr_ws, **alignAndFocusArgs) vanadium_title = "vanadium_and_background" save_banks(InputWorkspace=van_wksp, Filename=nexus_filename, Title=vanadium_title, OutputDir=OutputDir, GroupingWorkspace=grp_wksp, Binning=binning) van_material = mtd[van_wksp].sample().getMaterial() van_molecular_mass = van_material.relativeMolecularMass() nvan_atoms = getNumberAtoms(1.0, van_mass_density, van_molecular_mass, Geometry=van_geometry) print("Sample natoms:", natoms) print("Vanadium natoms:", nvan_atoms) print("Vanadium natoms / Sample natoms:", nvan_atoms / natoms) # Load Vanadium Background van_bg = None if van_bg_scans is not None: print("#-----------------------------------#") print("# Vanadium Background") print("#-----------------------------------#") van_bg = load('vanadium_background', van_bg_scans, **alignAndFocusArgs) vanadium_bg_title = "vanadium_background" save_banks(InputWorkspace=van_bg, Filename=nexus_filename, Title=vanadium_bg_title, OutputDir=OutputDir, GroupingWorkspace=grp_wksp, Binning=binning) # Load Instrument Characterizations if characterizations: PDDetermineCharacterizations( InputWorkspace=sam_wksp, Characterizations='characterizations', ReductionProperties='__snspowderreduction') propMan = PropertyManagerDataService.retrieve('__snspowderreduction') qmax = 2. * np.pi / propMan['d_min'].value qmin = 2. * np.pi / propMan['d_max'].value for a, b in zip(qmin, qmax): print('Qrange:', a, b) # TODO: Add when we apply Qmin, Qmax cropping # mask_info = generate_cropping_table(qmin, qmax) # STEP 1: Subtract Backgrounds sam_raw = 'sam_raw' CloneWorkspace(InputWorkspace=sam_wksp, OutputWorkspace=sam_raw) # for later container_raw = 'container_raw' CloneWorkspace(InputWorkspace=container, OutputWorkspace=container_raw) # for later if van_bg is not None: RebinToWorkspace(WorkspaceToRebin=van_bg, WorkspaceToMatch=van_wksp, OutputWorkspace=van_bg) Minus(LHSWorkspace=van_wksp, RHSWorkspace=van_bg, OutputWorkspace=van_wksp) RebinToWorkspace(WorkspaceToRebin=container, WorkspaceToMatch=sam_wksp, OutputWorkspace=container) Minus(LHSWorkspace=sam_wksp, RHSWorkspace=container, OutputWorkspace=sam_wksp) if container_bg is not None: RebinToWorkspace(WorkspaceToRebin=container_bg, WorkspaceToMatch=container, OutputWorkspace=container_bg) Minus(LHSWorkspace=container, RHSWorkspace=container_bg, OutputWorkspace=container) for wksp in [container, van_wksp, sam_wksp]: ConvertUnits(InputWorkspace=wksp, OutputWorkspace=wksp, Target="MomentumTransfer", EMode="Elastic") container_title = "container_minus_back" vanadium_title = "vanadium_minus_back" sample_title = "sample_minus_back" save_banks(InputWorkspace=container, Filename=nexus_filename, Title=container_title, OutputDir=OutputDir, GroupingWorkspace=grp_wksp, Binning=binning) save_banks(InputWorkspace=van_wksp, Filename=nexus_filename, Title=vanadium_title, OutputDir=OutputDir, GroupingWorkspace=grp_wksp, Binning=binning) save_banks(InputWorkspace=sam_wksp, Filename=nexus_filename, Title=sample_title, OutputDir=OutputDir, GroupingWorkspace=grp_wksp, Binning=binning) # STEP 2.0: Prepare vanadium as normalization calibrant # Multiple-Scattering and Absorption (Steps 2-4) for Vanadium van_corrected = 'van_corrected' ConvertUnits(InputWorkspace=van_wksp, OutputWorkspace=van_corrected, Target="Wavelength", EMode="Elastic") if "Type" in van_abs_corr: if van_abs_corr['Type'] == 'Carpenter' \ or van_ms_corr['Type'] == 'Carpenter': CarpenterSampleCorrection( InputWorkspace=van_corrected, OutputWorkspace=van_corrected, CylinderSampleRadius=van['Geometry']['Radius']) elif van_abs_corr['Type'] == 'Mayers' \ or van_ms_corr['Type'] == 'Mayers': if van_ms_corr['Type'] == 'Mayers': MayersSampleCorrection(InputWorkspace=van_corrected, OutputWorkspace=van_corrected, MultipleScattering=True) else: MayersSampleCorrection(InputWorkspace=van_corrected, OutputWorkspace=van_corrected, MultipleScattering=False) else: print("NO VANADIUM absorption or multiple scattering!") else: CloneWorkspace(InputWorkspace=van_corrected, OutputWorkspace=van_corrected) ConvertUnits(InputWorkspace=van_corrected, OutputWorkspace=van_corrected, Target='MomentumTransfer', EMode='Elastic') vanadium_title += "_ms_abs_corrected" save_banks(InputWorkspace=van_corrected, Filename=nexus_filename, Title=vanadium_title, OutputDir=OutputDir, GroupingWorkspace=grp_wksp, Binning=binning) save_banks(InputWorkspace=van_corrected, Filename=nexus_filename, Title=vanadium_title + "_with_peaks", OutputDir=OutputDir, GroupingWorkspace=grp_wksp, Binning=binning) # TODO subtract self-scattering of vanadium (According to Eq. 7 of Howe, # McGreevey, and Howells, JPCM, 1989) # Smooth Vanadium (strip peaks plus smooth) ConvertUnits(InputWorkspace=van_corrected, OutputWorkspace=van_corrected, Target='dSpacing', EMode='Elastic') # After StripVanadiumPeaks, the workspace goes from EventWorkspace -> # Workspace2D StripVanadiumPeaks(InputWorkspace=van_corrected, OutputWorkspace=van_corrected, BackgroundType='Quadratic') ConvertUnits(InputWorkspace=van_corrected, OutputWorkspace=van_corrected, Target='MomentumTransfer', EMode='Elastic') vanadium_title += '_peaks_stripped' save_banks(InputWorkspace=van_corrected, Filename=nexus_filename, Title=vanadium_title, OutputDir=OutputDir, GroupingWorkspace=grp_wksp, Binning=binning) ConvertUnits(InputWorkspace=van_corrected, OutputWorkspace=van_corrected, Target='TOF', EMode='Elastic') FFTSmooth(InputWorkspace=van_corrected, OutputWorkspace=van_corrected, Filter="Butterworth", Params='20,2', IgnoreXBins=True, AllSpectra=True) ConvertUnits(InputWorkspace=van_corrected, OutputWorkspace=van_corrected, Target='MomentumTransfer', EMode='Elastic') vanadium_title += '_smoothed' save_banks(InputWorkspace=van_corrected, Filename=nexus_filename, Title=vanadium_title, OutputDir=OutputDir, GroupingWorkspace=grp_wksp, Binning=binning) # Inelastic correction if van_inelastic_corr['Type'] == "Placzek": van_scan = van['Runs'][0] van_incident_wksp = 'van_incident_wksp' van_inelastic_opts = van['InelasticCorrection'] lambda_binning_fit = van_inelastic_opts['LambdaBinningForFit'] lambda_binning_calc = van_inelastic_opts['LambdaBinningForCalc'] print('van_scan:', van_scan) GetIncidentSpectrumFromMonitor(Filename=facility_file_format % (instr, van_scan), OutputWorkspace=van_incident_wksp) fit_type = van['InelasticCorrection']['FitSpectrumWith'] FitIncidentSpectrum(InputWorkspace=van_incident_wksp, OutputWorkspace=van_incident_wksp, FitSpectrumWith=fit_type, BinningForFit=lambda_binning_fit, BinningForCalc=lambda_binning_calc, PlotDiagnostics=False) van_placzek = 'van_placzek' SetSample(InputWorkspace=van_incident_wksp, Material={ 'ChemicalFormula': str(van_material), 'SampleMassDensity': str(van_mass_density) }) CalculatePlaczekSelfScattering(IncidentWorkspace=van_incident_wksp, ParentWorkspace=van_corrected, OutputWorkspace=van_placzek, L1=19.5, L2=alignAndFocusArgs['L2'], Polar=alignAndFocusArgs['Polar']) ConvertToHistogram(InputWorkspace=van_placzek, OutputWorkspace=van_placzek) # Save before rebin in Q for wksp in [van_placzek, van_corrected]: ConvertUnits(InputWorkspace=wksp, OutputWorkspace=wksp, Target='MomentumTransfer', EMode='Elastic') Rebin(InputWorkspace=wksp, OutputWorkspace=wksp, Params=binning, PreserveEvents=True) save_banks(InputWorkspace=van_placzek, Filename=nexus_filename, Title="vanadium_placzek", OutputDir=OutputDir, GroupingWorkspace=grp_wksp, Binning=binning) # Rebin in Wavelength for wksp in [van_placzek, van_corrected]: ConvertUnits(InputWorkspace=wksp, OutputWorkspace=wksp, Target='Wavelength', EMode='Elastic') Rebin(InputWorkspace=wksp, OutputWorkspace=wksp, Params=lambda_binning_calc, PreserveEvents=True) # Save after rebin in Q for wksp in [van_placzek, van_corrected]: ConvertUnits(InputWorkspace=wksp, OutputWorkspace=wksp, Target='MomentumTransfer', EMode='Elastic') # Subtract correction in Wavelength for wksp in [van_placzek, van_corrected]: ConvertUnits(InputWorkspace=wksp, OutputWorkspace=wksp, Target='Wavelength', EMode='Elastic') if not mtd[wksp].isDistribution(): ConvertToDistribution(wksp) Minus(LHSWorkspace=van_corrected, RHSWorkspace=van_placzek, OutputWorkspace=van_corrected) # Save after subtraction for wksp in [van_placzek, van_corrected]: ConvertUnits(InputWorkspace=wksp, OutputWorkspace=wksp, Target='MomentumTransfer', EMode='Elastic') vanadium_title += '_placzek_corrected' save_banks(InputWorkspace=van_corrected, Filename=nexus_filename, Title=vanadium_title, OutputDir=OutputDir, GroupingWorkspace=grp_wksp, Binning=binning) ConvertUnits(InputWorkspace=van_corrected, OutputWorkspace=van_corrected, Target='MomentumTransfer', EMode='Elastic') SetUncertainties(InputWorkspace=van_corrected, OutputWorkspace=van_corrected, SetError='zero') # STEP 2.1: Normalize by Vanadium wksp_list = [sam_wksp, sam_raw, van_corrected] for name in wksp_list: ConvertUnits(InputWorkspace=name, OutputWorkspace=name, Target='MomentumTransfer', EMode='Elastic', ConvertFromPointData=False) Rebin(InputWorkspace=name, OutputWorkspace=name, Params=binning, PreserveEvents=True) # Save the sample - back / normalized Divide(LHSWorkspace=sam_wksp, RHSWorkspace=van_corrected, OutputWorkspace=sam_wksp) sample_title += "_normalized" save_banks(InputWorkspace=sam_wksp, Filename=nexus_filename, Title=sample_title, OutputDir=OutputDir, GroupingWorkspace=grp_wksp, Binning=binning) # Save the sample / normalized (ie no background subtraction) Divide(LHSWorkspace=sam_raw, RHSWorkspace=van_corrected, OutputWorkspace=sam_raw) save_banks(InputWorkspace=sam_raw, Filename=nexus_filename, Title="sample_normalized", OutputDir=OutputDir, GroupingWorkspace=grp_wksp, Binning=binning) # Output an initial I(Q) for sample iq_filename = title + '_initial_iofq_banks.nxs' save_banks(InputWorkspace=sam_wksp, Filename=iq_filename, Title="IQ_banks", OutputDir=OutputDir, GroupingWorkspace=grp_wksp, Binning=binning) wksp_list = [container, container_raw, van_corrected] if container_bg is not None: wksp_list.append(container_bg) if van_bg is not None: wksp_list.append(van_bg) for name in wksp_list: ConvertUnits(InputWorkspace=name, OutputWorkspace=name, Target='MomentumTransfer', EMode='Elastic', ConvertFromPointData=False) Rebin(InputWorkspace=name, OutputWorkspace=name, Params=binning, PreserveEvents=True) # Save the container - container_background / normalized Divide(LHSWorkspace=container, RHSWorkspace=van_corrected, OutputWorkspace=container) container_title += '_normalized' save_banks(InputWorkspace=container, Filename=nexus_filename, Title=container_title, OutputDir=OutputDir, GroupingWorkspace=grp_wksp, Binning=binning) # Save the container / normalized (ie no background subtraction) Divide(LHSWorkspace=container_raw, RHSWorkspace=van_corrected, OutputWorkspace=container_raw) save_banks(InputWorkspace=container_raw, Filename=nexus_filename, Title="container_normalized", OutputDir=OutputDir, GroupingWorkspace=grp_wksp, Binning=binning) # Save the container_background / normalized if container_bg is not None: Divide(LHSWorkspace=container_bg, RHSWorkspace=van_corrected, OutputWorkspace=container_bg) container_bg_title = "container_back_normalized" save_banks(InputWorkspace=container_bg, Filename=nexus_filename, Title=container_bg_title, OutputDir=OutputDir, GroupingWorkspace=grp_wksp, Binning=binning) # Save the vanadium_background / normalized if van_bg is not None: Divide(LHSWorkspace=van_bg, RHSWorkspace=van_corrected, OutputWorkspace=van_bg) vanadium_bg_title += "_normalized" save_banks(InputWorkspace=van_bg, Filename=nexus_filename, Title=vanadium_bg_title, OutputDir=OutputDir, GroupingWorkspace=grp_wksp, Binning=binning) # STEP 3 & 4: Subtract multiple scattering and apply absorption correction ConvertUnits(InputWorkspace=sam_wksp, OutputWorkspace=sam_wksp, Target="Wavelength", EMode="Elastic") sam_corrected = 'sam_corrected' if sam_abs_corr and sam_ms_corr: if sam_abs_corr['Type'] == 'Carpenter' \ or sam_ms_corr['Type'] == 'Carpenter': CarpenterSampleCorrection( InputWorkspace=sam_wksp, OutputWorkspace=sam_corrected, CylinderSampleRadius=sample['Geometry']['Radius']) elif sam_abs_corr['Type'] == 'Mayers' \ or sam_ms_corr['Type'] == 'Mayers': if sam_ms_corr['Type'] == 'Mayers': MayersSampleCorrection(InputWorkspace=sam_wksp, OutputWorkspace=sam_corrected, MultipleScattering=True) else: MayersSampleCorrection(InputWorkspace=sam_wksp, OutputWorkspace=sam_corrected, MultipleScattering=False) else: print("NO SAMPLE absorption or multiple scattering!") CloneWorkspace(InputWorkspace=sam_wksp, OutputWorkspace=sam_corrected) ConvertUnits(InputWorkspace=sam_corrected, OutputWorkspace=sam_corrected, Target='MomentumTransfer', EMode='Elastic') sample_title += "_ms_abs_corrected" save_banks(InputWorkspace=sam_corrected, Filename=nexus_filename, Title=sample_title, OutputDir=OutputDir, GroupingWorkspace=grp_wksp, Binning=binning) else: CloneWorkspace(InputWorkspace=sam_wksp, OutputWorkspace=sam_corrected) # STEP 5: Divide by number of atoms in sample mtd[sam_corrected] = (nvan_atoms / natoms) * mtd[sam_corrected] ConvertUnits(InputWorkspace=sam_corrected, OutputWorkspace=sam_corrected, Target='MomentumTransfer', EMode='Elastic') sample_title += "_norm_by_atoms" save_banks(InputWorkspace=sam_corrected, Filename=nexus_filename, Title=sample_title, OutputDir=OutputDir, GroupingWorkspace=grp_wksp, Binning=binning) # STEP 6: Divide by total scattering length squared = total scattering # cross-section over 4 * pi van_material = mtd[van_corrected].sample().getMaterial() sigma_v = van_material.totalScatterXSection() prefactor = (sigma_v / (4. * np.pi)) msg = "Total scattering cross-section of Vanadium:{} sigma_v / 4*pi: {}" print(msg.format(sigma_v, prefactor)) mtd[sam_corrected] = prefactor * mtd[sam_corrected] sample_title += '_multiply_by_vanSelfScat' save_banks(InputWorkspace=sam_corrected, Filename=nexus_filename, Title=sample_title, OutputDir=OutputDir, GroupingWorkspace=grp_wksp, Binning=binning) # STEP 7: Inelastic correction ConvertUnits(InputWorkspace=sam_corrected, OutputWorkspace=sam_corrected, Target='Wavelength', EMode='Elastic') if sam_inelastic_corr['Type'] == "Placzek": if sam_material is None: error = "For Placzek correction, must specifiy a sample material." raise Exception(error) for sam_scan in sample['Runs']: sam_incident_wksp = 'sam_incident_wksp' sam_inelastic_opts = sample['InelasticCorrection'] lambda_binning_fit = sam_inelastic_opts['LambdaBinningForFit'] lambda_binning_calc = sam_inelastic_opts['LambdaBinningForCalc'] GetIncidentSpectrumFromMonitor(Filename=facility_file_format % (instr, sam_scan), OutputWorkspace=sam_incident_wksp) fit_type = sample['InelasticCorrection']['FitSpectrumWith'] FitIncidentSpectrum(InputWorkspace=sam_incident_wksp, OutputWorkspace=sam_incident_wksp, FitSpectrumWith=fit_type, BinningForFit=lambda_binning_fit, BinningForCalc=lambda_binning_calc) sam_placzek = 'sam_placzek' SetSample(InputWorkspace=sam_incident_wksp, Material={ 'ChemicalFormula': str(sam_material), 'SampleMassDensity': str(sam_mass_density) }) CalculatePlaczekSelfScattering(IncidentWorkspace=sam_incident_wksp, ParentWorkspace=sam_corrected, OutputWorkspace=sam_placzek, L1=19.5, L2=alignAndFocusArgs['L2'], Polar=alignAndFocusArgs['Polar']) ConvertToHistogram(InputWorkspace=sam_placzek, OutputWorkspace=sam_placzek) # Save before rebin in Q for wksp in [sam_placzek, sam_corrected]: ConvertUnits(InputWorkspace=wksp, OutputWorkspace=wksp, Target='MomentumTransfer', EMode='Elastic') Rebin(InputWorkspace=wksp, OutputWorkspace=wksp, Params=binning, PreserveEvents=True) save_banks(InputWorkspace=sam_placzek, Filename=nexus_filename, Title="sample_placzek", OutputDir=OutputDir, GroupingWorkspace=grp_wksp, Binning=binning) # Save after rebin in Q for wksp in [sam_placzek, sam_corrected]: ConvertUnits(InputWorkspace=wksp, OutputWorkspace=wksp, Target='MomentumTransfer', EMode='Elastic') Minus(LHSWorkspace=sam_corrected, RHSWorkspace=sam_placzek, OutputWorkspace=sam_corrected) # Save after subtraction for wksp in [sam_placzek, sam_corrected]: ConvertUnits(InputWorkspace=wksp, OutputWorkspace=wksp, Target='MomentumTransfer', EMode='Elastic') sample_title += '_placzek_corrected' save_banks(InputWorkspace=sam_corrected, Filename=nexus_filename, Title=sample_title, OutputDir=OutputDir, GroupingWorkspace=grp_wksp, Binning=binning) # STEP 7: Output spectrum # TODO Since we already went from Event -> 2D workspace, can't use this # anymore print('sam:', mtd[sam_corrected].id()) print('van:', mtd[van_corrected].id()) if alignAndFocusArgs['PreserveEvents']: CompressEvents(InputWorkspace=sam_corrected, OutputWorkspace=sam_corrected) # F(Q) bank-by-bank Section fq_banks_wksp = "FQ_banks_wksp" CloneWorkspace(InputWorkspace=sam_corrected, OutputWorkspace=fq_banks_wksp) # TODO: Add the following when implemented - FQ_banks = 'FQ_banks' # S(Q) bank-by-bank Section material = mtd[sam_corrected].sample().getMaterial() if material.name() is None or len(material.name().strip()) == 0: raise RuntimeError('Sample material was not set') bcoh_avg_sqrd = material.cohScatterLength() * material.cohScatterLength() btot_sqrd_avg = material.totalScatterLengthSqrd() laue_monotonic_diffuse_scat = btot_sqrd_avg / bcoh_avg_sqrd sq_banks_wksp = 'SQ_banks_wksp' CloneWorkspace(InputWorkspace=sam_corrected, OutputWorkspace=sq_banks_wksp) # TODO: Add the following when implemented ''' SQ_banks = (1. / bcoh_avg_sqrd) * \ mtd[sq_banks_wksp] - laue_monotonic_diffuse_scat + 1. ''' # Save S(Q) and F(Q) to diagnostics NeXus file save_banks(InputWorkspace=fq_banks_wksp, Filename=nexus_filename, Title="FQ_banks", OutputDir=OutputDir, GroupingWorkspace=grp_wksp, Binning=binning) save_banks(InputWorkspace=sq_banks_wksp, Filename=nexus_filename, Title="SQ_banks", OutputDir=OutputDir, GroupingWorkspace=grp_wksp, Binning=binning) # Output a main S(Q) and F(Q) file fq_filename = title + '_fofq_banks_corrected.nxs' save_banks(InputWorkspace=fq_banks_wksp, Filename=fq_filename, Title="FQ_banks", OutputDir=OutputDir, GroupingWorkspace=grp_wksp, Binning=binning) sq_filename = title + '_sofq_banks_corrected.nxs' save_banks(InputWorkspace=sq_banks_wksp, Filename=sq_filename, Title="SQ_banks", OutputDir=OutputDir, GroupingWorkspace=grp_wksp, Binning=binning) # Print log information print("<b>^2:", bcoh_avg_sqrd) print("<b^2>:", btot_sqrd_avg) print("Laue term:", laue_monotonic_diffuse_scat) print("sample total xsection:", mtd[sam_corrected].sample().getMaterial().totalScatterXSection()) print("vanadium total xsection:", mtd[van_corrected].sample().getMaterial().totalScatterXSection()) # Output Bragg Diffraction ConvertUnits(InputWorkspace=sam_corrected, OutputWorkspace=sam_corrected, Target="TOF", EMode="Elastic") ConvertToHistogram(InputWorkspace=sam_corrected, OutputWorkspace=sam_corrected) xmin, xmax = get_each_spectra_xmin_xmax(mtd[sam_corrected]) CropWorkspaceRagged(InputWorkspace=sam_corrected, OutputWorkspace=sam_corrected, Xmin=xmin, Xmax=xmax) xmin_rebin = min(xmin) xmax_rebin = max(xmax) tof_binning = "{xmin},-0.01,{xmax}".format(xmin=xmin_rebin, xmax=xmax_rebin) Rebin(InputWorkspace=sam_corrected, OutputWorkspace=sam_corrected, Params=tof_binning) SaveGSS(InputWorkspace=sam_corrected, Filename=os.path.join(os.path.abspath(OutputDir), title + ".gsa"), SplitFiles=False, Append=False, MultiplyByBinWidth=True, Format="SLOG", ExtendedHeader=True) return mtd[sam_corrected]
def save(self, diff_ws_name, run_date_time, gsas_file_name, ipts_number, run_number, gsas_param_file_name, align_vdrive_bin, van_ws_name, is_chopped_run, write_to_file=True): """ Save a workspace to a GSAS file or a string :param diff_ws_name: diffraction data workspace :param run_date_time: date and time of the run :param gsas_file_name: output file name. None as not output :param ipts_number: :param run_number: if not None, run number :param gsas_param_file_name: :param align_vdrive_bin: Flag to align with VDRIVE bin edges/boundaries :param van_ws_name: name of vanadium workspaces loaded from GSAS (replacing vanadium_gsas_file) :param is_chopped_run: Flag such that the input workspaces is from an event-sliced workspace :param write_to_file: flag to write the text buffer to file :return: string as the file content """ diff_ws = mantid_helper.retrieve_workspace(diff_ws_name) # set the unit to TOF if diff_ws.getAxis(0).getUnit() != 'TOF': ConvertUnits(InputWorkspace=diff_ws_name, OutputWorkspace=diff_ws_name, Target='TOF', EMode='Elastic') diff_ws = mantid_helper.retrieve_workspace(diff_ws_name) # convert to Histogram Data if not diff_ws.isHistogramData(): ConvertToHistogram(diff_ws_name, diff_ws_name) # get the binning parameters if align_vdrive_bin: bin_params_set = self._get_tof_bin_params( self._get_vulcan_phase(run_date_time), diff_ws.getNumberHistograms()) else: # a binning parameter set for doing nothing bin_params_set = [(range(1, diff_ws.getNumberHistograms() + 1), None, None)] # check for vanadium GSAS file name if van_ws_name is not None: # check whether a workspace exists if not mantid_helper.workspace_does_exist(van_ws_name): raise RuntimeError( 'Vanadium workspace {} does not exist in Mantid ADS'. format(van_ws_name)) van_ws = mantid_helper.retrieve_workspace(van_ws_name) # check number of histograms if mantid_helper.get_number_spectra( van_ws) != mantid_helper.get_number_spectra(diff_ws): raise RuntimeError( 'Numbers of histograms between vanadium spectra and output GSAS are different' ) else: van_ws = None # END-IF # rebin and then write output gsas_bank_buffer_dict = dict() num_bank_sets = len(bin_params_set) for bank_set_index in range(num_bank_sets): # get value bank_id_list, bin_params, tof_vector = bin_params_set[ bank_set_index] # Rebin to these banks' parameters (output = Histogram) if bin_params is not None: Rebin(InputWorkspace=diff_ws_name, OutputWorkspace=diff_ws_name, Params=bin_params, PreserveEvents=True) # Create output for bank_id in bank_id_list: # check vanadium bin edges if van_ws is not None: # check whether the bins are same between GSAS workspace and vanadium workspace unmatched, reason = self._compare_workspaces_dimension( van_ws, bank_id, tof_vector) if unmatched: raise RuntimeError( 'Vanadium GSAS workspace {} does not match workspace {}: {}' ''.format(van_ws_name, diff_ws_name, reason)) # END-IF # write GSAS head considering vanadium gsas_section_i = self._write_slog_bank_gsas( diff_ws_name, bank_id, tof_vector, van_ws) gsas_bank_buffer_dict[bank_id] = gsas_section_i # END-FOR # header diff_ws = mantid_helper.retrieve_workspace(diff_ws_name) gsas_header = self._generate_vulcan_gda_header(diff_ws, gsas_file_name, ipts_number, run_number, gsas_param_file_name, is_chopped_run) # form to a big string gsas_buffer = gsas_header for bank_id in sorted(gsas_bank_buffer_dict.keys()): gsas_buffer += gsas_bank_buffer_dict[bank_id] # write to HDD if write_to_file: datatypeutility.check_file_name(gsas_file_name, check_exist=False, check_writable=True, is_dir=False, note='Output GSAS file') g_file = open(gsas_file_name, 'w') g_file.write(gsas_buffer) g_file.close() else: pass return gsas_buffer
def save_2theta_group(self, diff_ws_name, output_dir, run_date_time, ipts_number, run_number, gsas_param_file_name, van_ws_name, two_theta_array, tth_pixels_num_array, target_bank_id, scale_factor): """ Save workspace from 2theta grouped :param diff_ws_name: :param output_dir: :param run_date_time: :param ipts_number: :param run_number: :param gsas_param_file_name: :param van_ws_name: :param two_theta_array: :param tth_pixels_num_array: array of integers for number of pixels of 2theta range for normalization :param target_bank_id: :return: """ # process input workspaces diff_ws = mantid_helper.retrieve_workspace(diff_ws_name) # set the unit to TOF if diff_ws.getAxis(0).getUnit() != 'TOF': ConvertUnits(InputWorkspace=diff_ws_name, OutputWorkspace=diff_ws_name, Target='TOF', EMode='Elastic') diff_ws = mantid_helper.retrieve_workspace(diff_ws_name) # convert to Histogram Data if not diff_ws.isHistogramData(): ConvertToHistogram(diff_ws_name, diff_ws_name) # vanadium if isinstance(van_ws_name, str) and len(van_ws_name) > 0: van_ws = mantid_helper.retrieve_workspace(van_ws_name) else: van_ws = None # get the binning parameters bin_params_set = self._get_tof_bin_params( self._get_vulcan_phase(run_date_time), 3) # check output directory if not os.path.exists(output_dir): os.mkdir(output_dir) # For each 2theta bin / spectrum, create a GSAS file for tth_id in range(diff_ws.getNumberHistograms()): # rebin and then write output gsas_bank_buffer_dict = dict() num_bank_sets = len(bin_params_set) for bank_set_index in range(num_bank_sets): # get value bank_id_list, bin_params, tof_vector = bin_params_set[ bank_set_index] # Rebin to these banks' parameters (output = Histogram) if bin_params is not None: Rebin(InputWorkspace=diff_ws_name, OutputWorkspace=diff_ws_name, Params=bin_params, PreserveEvents=True) # Create output for bank_id_i in bank_id_list: # check vanadium bin edges if van_ws is not None: # check whether the bins are same between GSAS workspace and vanadium workspace unmatched, reason = self._compare_workspaces_dimension( van_ws, bank_id_i, tof_vector) if unmatched: raise RuntimeError( 'Vanadium GSAS workspace {} does not match workspace {}: {}' ''.format(van_ws_name, diff_ws_name, reason)) # END-IF # write GSAS head considering vanadium if bank_id_i == target_bank_id: # target bank to write: east/west source_bank_id = tth_id + 1 norm_factor = tth_pixels_num_array[tth_id] else: source_bank_id = bank_id_i norm_factor = -1 gsas_section_i = self._write_slog_bank_gsas( diff_ws_name, source_bank_id, tof_vector, van_ws, gsas_bank_id=bank_id_i, norm_factor=norm_factor, scale_factor=scale_factor) gsas_bank_buffer_dict[bank_id_i] = gsas_section_i print('[DB...BAT] Write bank {} to GSAS bank {}'.format( source_bank_id, bank_id_i)) # END-FOR # header diff_ws = mantid_helper.retrieve_workspace(diff_ws_name) gsas_file_name = os.path.join(output_dir, '{}.gda'.format(tth_id + 1)) extra_info = '2theta {} to {}'.format( two_theta_array[tth_id], two_theta_array[[tth_id + 1]]) gsas_header = self._generate_vulcan_gda_header( diff_ws, gsas_file_name, ipts_number, run_number, gsas_param_file_name, True, extra_info) # form to a big string gsas_buffer = gsas_header for bank_id in sorted(gsas_bank_buffer_dict.keys()): gsas_buffer += gsas_bank_buffer_dict[bank_id] # write to HDD datatypeutility.check_file_name(gsas_file_name, check_exist=False, check_writable=True, is_dir=False, note='Output GSAS file') g_file = open(gsas_file_name, 'w') g_file.write(gsas_buffer) g_file.close() # END-FOR (tth_id) return