def _sumForegroundInLambda(self, ws):
"""Sum the foreground region into a single histogram."""
foreground = self._foregroundIndices(ws)
sumIndices = [i for i in range(foreground[0], foreground[2] + 1)]
beamPosIndex = foreground[1]
foregroundWSName = self._names.withSuffix('foreground_grouped')
foregroundWS = ExtractSingleSpectrum(InputWorkspace=ws,
OutputWorkspace=foregroundWSName,
WorkspaceIndex=beamPosIndex,
EnableLogging=self._subalgLogging)
maxIndex = ws.getNumberHistograms() - 1
foregroundYs = foregroundWS.dataY(0)
foregroundEs = foregroundWS.dataE(0)
numpy.square(foregroundEs, out=foregroundEs)
for i in sumIndices:
if i == beamPosIndex:
continue
if i < 0 or i > maxIndex:
self.log().warning(
'Foreground partially out of the workspace.')
ys = ws.readY(i)
foregroundYs += ys
es = ws.readE(i)
foregroundEs += es**2
numpy.sqrt(foregroundEs, out=foregroundEs)
self._cleanup.cleanup(ws)
AddSampleLog(Workspace=foregroundWS,
LogName=common.SampleLogs.SUM_TYPE,
LogText=SumType.IN_LAMBDA,
LogType='String',
EnableLogging=self._subalgLogging)
ConvertToDistribution(Workspace=foregroundWS,
EnableLogging=self._subalgLogging)
return foregroundWS
def convert_to_matrix(self):
ws_conv = ConvertMDHistoToMatrixWorkspace(self.name, Normalization='NumEventsNormalization',
FindXAxis=False, StoreInADS=False, OutputWorkspace=self.name)
coord = self.get_coordinates()
bin_size = coord[coord.keys()[0]][1] - coord[coord.keys()[0]][0]
ws_conv = Scale(ws_conv, bin_size, OutputWorkspace=self.name, StoreInADS=False)
ConvertToDistribution(ws_conv, StoreInADS=False)
return Workspace(ws_conv, self.name)
def test_view_closes_on_replace_when_model_properties_change(self):
ws = CreateSampleWorkspace()
pres = SliceViewer(ws)
ConvertToDistribution(ws)
QApplication.sendPostedEvents()
self.assert_no_toplevel_widgets()
self.assertEqual(pres.ads_observer, None)
def runTest(self):
HelperTestingClass.__init__(self)
ws = CreateSampleWorkspace()
pres = SliceViewer(ws)
ConvertToDistribution(ws)
self._qapp.sendPostedEvents()
self.assert_no_toplevel_widgets()
self.assertEqual(pres.ads_observer, None)
def _convertToDistribution(self, mainWS, wsNames, wsCleanup, subalgLogging):
"""Convert the workspace into a distribution."""
distributionWSName = wsNames.withSuffix('as_distribution')
distributionWS = CloneWorkspace(InputWorkspace=mainWS,
OutputWorkspace=distributionWSName,
EnableLogging=subalgLogging)
wsCleanup.cleanup(mainWS)
ConvertToDistribution(Workspace=distributionWS,
EnableLogging=subalgLogging)
return distributionWS
def PyExec(self):
raw_ws = self.getProperty('InputWorkspace').value
sample_geometry = self.getPropertyValue('SampleGeometry')
sample_material = self.getPropertyValue('SampleMaterial')
cal_file_name = self.getPropertyValue('CalFileName')
SetSample(InputWorkspace=raw_ws,
Geometry=sample_geometry,
Material=sample_material)
# find the closest monitor to the sample for incident spectrum
raw_spec_info = raw_ws.spectrumInfo()
incident_index = None
for i in range(raw_spec_info.size()):
if raw_spec_info.isMonitor(i):
l2 = raw_spec_info.position(i)[2]
if not incident_index:
incident_index = i
else:
if raw_spec_info.position(incident_index)[2] < l2 < 0:
incident_index = i
monitor = ExtractSpectra(InputWorkspace=raw_ws,
WorkspaceIndexList=[incident_index])
monitor = ConvertUnits(InputWorkspace=monitor, Target="Wavelength")
x_data = monitor.dataX(0)
min_x = np.min(x_data)
max_x = np.max(x_data)
width_x = (max_x - min_x) / x_data.size
fit_spectra = FitIncidentSpectrum(
InputWorkspace=monitor,
BinningForCalc=[min_x, 1 * width_x, max_x],
BinningForFit=[min_x, 10 * width_x, max_x],
FitSpectrumWith="CubicSpline")
self_scattering_correction = CalculatePlaczekSelfScattering(
InputWorkspace=raw_ws, IncidentSpecta=fit_spectra)
cal_workspace = LoadCalFile(InputWorkspace=self_scattering_correction,
CalFileName=cal_file_name,
Workspacename='cal_workspace',
MakeOffsetsWorkspace=False,
MakeMaskWorkspace=False)
self_scattering_correction = DiffractionFocussing(
InputWorkspace=self_scattering_correction,
GroupingFilename=cal_file_name)
n_pixel = np.zeros(self_scattering_correction.getNumberHistograms())
for i in range(cal_workspace.getNumberHistograms()):
grouping = cal_workspace.dataY(i)
if grouping[0] > 0:
n_pixel[int(grouping[0] - 1)] += 1
correction_ws = CreateWorkspace(
DataY=n_pixel,
DataX=[0, 1],
NSpec=self_scattering_correction.getNumberHistograms())
self_scattering_correction = Divide(
LHSWorkspace=self_scattering_correction,
RHSWorkspace=correction_ws)
ConvertToDistribution(Workspace=self_scattering_correction)
self_scattering_correction = ConvertUnits(
InputWorkspace=self_scattering_correction,
Target="MomentumTransfer",
EMode='Elastic')
DeleteWorkspace('cal_workspace_group')
DeleteWorkspace(correction_ws)
DeleteWorkspace(fit_spectra)
DeleteWorkspace(monitor)
DeleteWorkspace(raw_ws)
self.setProperty('OutputWorkspace', self_scattering_correction)
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 _convertToDistribution(self, mainWS):
"""Convert the workspace into a distribution."""
ConvertToDistribution(Workspace=mainWS,
EnableLogging=self._subalgLogging)
return mainWS
def save_banks(InputWorkspace,
Filename,
Title,
OutputDir,
Binning=None,
GroupingWorkspace=None):
"""
Saves input workspace to processed NeXus file in specified
output directory with optional rebinning and grouping
(to coarsen) the output in a bank-by-bank manner. Mainly
wraps Mantid `SaveNexusProcessed` algorithm.
:param InputWorkspace: Mantid workspace to save out
:type InputWorkspace: MatrixWorkspace
:param Filename: Filename to save output
:type Filename: str
:param Title: A title to describe the saved workspace
:type Title: str
:param OutputDir: Output directory to save the processed NeXus file
:type OutputDir: path str
:param Binning: Optional rebinning of event workspace.
See `Rebin` in Mantid for options
:type Binning: dbl list
:param GroupingWorkspace: A workspace with grouping
information for the output spectra
:type GroupWorkspace: GroupWorkspace
"""
# Make a local clone
CloneWorkspace(InputWorkspace=InputWorkspace, OutputWorkspace="__tmp")
tmp_wksp = mtd["__tmp"]
# Rebin if requested
if Binning:
tmp_wksp = Rebin(InputWorkspace=tmp_wksp,
Params=Binning,
PreserveEvents=True)
# Convert to distributions to remove bin width dependence
yunit = tmp_wksp.YUnit()
if yunit == "Counts":
try:
ConvertToDistribution(tmp_wksp)
except BaseException:
pass
# Output to desired level of grouping
isEventWksp = isinstance(tmp_wksp, IEventWorkspace)
if isEventWksp and GroupingWorkspace and yunit == "Counts":
tmp_wksp = DiffractionFocussing(InputWorkspace=tmp_wksp,
GroupingWorkspace=GroupingWorkspace,
PreserveEvents=False)
# Save out wksp to file
filename = os.path.join(os.path.abspath(OutputDir), Filename)
SaveNexusProcessed(InputWorkspace=tmp_wksp,
Filename=filename,
Title=Title,
Append=True,
PreserveEvents=False,
WorkspaceIndexList=range(
tmp_wksp.getNumberHistograms()))
DeleteWorkspace(tmp_wksp)