def dynamicsusceptibility(workspace, temperature, outputName=None, zeroEnergyEpsilon=1e-6):
"""Convert :math:`S(Q,E)` to susceptibility :math:`\chi''(Q,E)`.
#. If the X units are not in DeltaE, the workspace is transposed
#. The Y data in *workspace* is multiplied by :math:`1 - e^{\Delta E / (kT)}`
#. Y data in the bin closest to 0 meV and within -*zeroEnergyEpsilon* < :math:`\Delta E` < *zeroEnergyEpsilon* is set to 0
#. If the input was transposed, transpose the output as well
:param workspace: a :math:`S(Q,E)` workspace to convert
:type workspace: :class:`mantid.api.MatrixWorkspace`
:param temperature: temperature in Kelvin
:type temperature: float
:param outputName: name of the output workspace. If :class:`None`, the output will be given some generated name.
:type outputName: str or None
:param zeroEnergyEpsilon: if a bin center is within this value from 0, the bin's value is set to zero.
:type zeroEnergyEpsilon: float
:returns: a :class:`mantid.api.MatrixWorkspace` containing :math:`\chi''(Q,E)`
"""
workspace = _normws(workspace)
horAxis = workspace.getAxis(0)
horUnit = horAxis.getUnit().unitID()
doTranspose = horUnit != 'DeltaE'
if outputName is None:
outputName = 'CHIofQW_{}'.format(str(workspace))
if doTranspose:
workspace = Transpose(workspace, OutputWorkspace='__transposed_SofQW_', EnableLogging=False)
c = 1e-3 * constants.e / constants.k / temperature
outWS = OneMinusExponentialCor(workspace, OutputWorkspace=outputName, C=c, Operation='Multiply', EnableLogging=False)
_removesingularity(outWS, zeroEnergyEpsilon)
if doTranspose:
outWS = Transpose(outWS, OutputWorkspace=outputName, EnableLogging=False)
DeleteWorkspace('__transposed_SofQW_', EnableLogging=False)
outWS.setYUnit("Dynamic susceptibility")
return outWS
def dynamicsusceptibility(workspace, temperature, outputName=None, zeroEnergyEpsilon=1e-6):
"""Convert :math:`S(Q,E)` to susceptibility :math:`\chi''(Q,E)`.
#. If the X units are not in DeltaE, the workspace is transposed
#. The Y data in *workspace* is multiplied by :math:`1 - e^{\Delta E / (kT)}`
#. Y data in the bin closest to 0 meV and within -*zeroEnergyEpsilon* < :math:`\Delta E` < *zeroEnergyEpsilon* is set to 0
#. If the input was transposed, transpose the output as well
:param workspace: a :math:`S(Q,E)` workspace to convert
:type workspace: :class:`mantid.api.MatrixWorkspace`
:param temperature: temperature in Kelvin
:type temperature: float
:param outputName: name of the output workspace. If :class:`None`, the output will be given some generated name.
:type outputName: str or None
:param zeroEnergyEpsilon: if a bin center is within this value from 0, the bin's value is set to zero.
:type zeroEnergyEpsilon: float
:returns: a :class:`mantid.api.MatrixWorkspace` containing :math:`\chi''(Q,E)`
"""
workspace = _normws(workspace)
horAxis = workspace.getAxis(0)
horUnit = horAxis.getUnit().unitID()
doTranspose = horUnit != 'DeltaE'
if outputName is None:
outputName = 'CHIofQW_{}'.format(str(workspace))
if doTranspose:
workspace = Transpose(workspace, OutputWorkspace='__transposed_SofQW_', EnableLogging=False)
c = 1e-3 * constants.e / constants.k / temperature
outWS = OneMinusExponentialCor(workspace, OutputWorkspace=outputName, C=c, Operation='Multiply', EnableLogging=False)
_removesingularity(outWS, zeroEnergyEpsilon)
if doTranspose:
outWS = Transpose(outWS, OutputWorkspace=outputName, EnableLogging=False)
DeleteWorkspace('__transposed_SofQW_', EnableLogging=False)
outWS.setYUnit('Dynamic susceptibility')
return outWS
def process_monitor_efficiency(workspace_name):
"""
Process monitor efficiency for a given workspace.
@param workspace_name Name of workspace to process monitor for
"""
from mantid.simpleapi import OneMinusExponentialCor
monitor_workspace_name = workspace_name + '_mon'
instrument = mtd[workspace_name].getInstrument()
try:
area = instrument.getNumberParameter('Workflow.Monitor1-Area')[0]
thickness = instrument.getNumberParameter(
'Workflow.Monitor1-Thickness')[0]
attenuation = instrument.getNumberParameter(
'Workflow.Monitor1-Attenuation')[0]
except IndexError:
raise ValueError('Cannot get monitor details form parameter file')
if area == -1 or thickness == -1 or attenuation == -1:
logger.information('For workspace %s, skipping monitor efficiency' %
workspace_name)
return
OneMinusExponentialCor(InputWorkspace=monitor_workspace_name,
OutputWorkspace=monitor_workspace_name,
C=attenuation * thickness,
C1=area)
def _monitor_normalization(self, w, target):
"""
Divide data by integrated monitor intensity
Parameters
----------
w: Mantid.EventsWorkspace
Input workspace
target: str
Specify the entity the workspace refers to. Valid options are
'sample', 'background', and 'vanadium'
Returns
-------
Mantid.EventWorkspace
"""
_t_mon = self._load_monitors(target)
_t_mon = ConvertUnits(_t_mon, Target='Wavelength', Emode='Elastic')
_t_mon = CropWorkspace(_t_mon,
XMin=self._wavelength_band[0],
XMax=self._wavelength_band[1])
_t_mon = OneMinusExponentialCor(_t_mon,
C='0.20749999999999999',
C1='0.001276')
_t_mon = Scale(_t_mon, Factor='1e-06', Operation='Multiply')
_t_mon = Integration(_t_mon) # total monitor count
_t_w = Divide(w, _t_mon, OutputWorkspace=w.name())
return _t_w
def _calculate_wavelength_band(self):
"""
Calculate the wavelength band using the monitors from the sample runs
Consider wavelenghts with an associated intensity above a certain
fraction of the maximum observed intensity.
"""
_t_w = self._load_monitors('sample')
_t_w = ConvertUnits(_t_w, Target='Wavelength', Emode='Elastic')
l_min, l_max = 0.0, 20.0
_t_w = CropWorkspace(_t_w, XMin=l_min, XMax=l_max)
_t_w = OneMinusExponentialCor(_t_w,
C='0.20749999999999999',
C1='0.001276')
_t_w = Scale(_t_w, Factor='1e-06', Operation='Multiply')
_t_w = Rebin(_t_w,
Params=[l_min, self._wavelength_dl, l_max],
PreserveEvents=False)
y = _t_w.readY(0)
k = np.argmax(y) # y[k] is the maximum observed intensity
factor = 0.8 # 80% of the maximum intensity
i_s = k - 1
while y[i_s] > factor * y[k]:
i_s -= 1
i_e = k + 1
while y[i_e] > factor * y[k]:
i_e += 1
x = _t_w.readX(0)
self._wavelength_band = [x[i_s], x[i_e]]
def _flux_normalization(self, w, target):
"""
Divide data by integrated flux intensity
Parameters
----------
w: Mantid.EventsWorkspace
Input workspace
target: str
Specify the entity the workspace refers to. Valid options are
'sample', 'background', and 'vanadium'
Returns
-------
Mantid.EventWorkspace
"""
valid_targets = ('sample', 'background', 'vanadium')
if target not in valid_targets:
raise KeyError('Target must be one of ' + ', '.join(valid_targets))
w_nor = None
if self._flux_normalization_type == 'Monitor':
_t_flux = None
_t_flux_name = tws('monitor_aggregate')
target_to_runs = dict(sample='RunNumbers',
background='BackgroundRuns',
vanadium='VanadiumRuns')
rl = self._run_list(self.getProperty(target_to_runs[target]).value)
_t_w_name = tws('monitor')
for run in rl:
run_name = '{0}_{1}'.format(self._short_inst, str(run))
_t_w = LoadNexusMonitors(run_name, OutputWorkspace=_t_w_name)
if _t_flux is None:
_t_flux = CloneWorkspace(_t_w,
OutputWorkspace=_t_flux_name)
else:
_t_flux = Plus(_t_flux, _t_w, OutputWorkspace=_t_flux_name)
_t_flux = ConvertUnits(_t_flux,
Target='Wavelength',
Emode='Elastic',
OutputWorkspace=_t_flux_name)
_t_flux = CropWorkspace(_t_flux,
XMin=self._wavelength_band[0],
XMax=self._wavelength_band[1],
OutputWorkspace=_t_flux_name)
_t_flux = OneMinusExponentialCor(_t_flux,
C='0.20749999999999999',
C1='0.001276',
OutputWorkspace=_t_flux_name)
_t_flux = Scale(_t_flux,
Factor='1e-06',
Operation='Multiply',
OutputWorkspace=_t_flux_name)
_t_flux = Integration(_t_flux,
RangeLower=self._wavelength_band[0],
RangeUpper=self._wavelength_band[1],
OutputWorkspace=_t_flux_name)
w_nor = Divide(w, _t_flux, OutputWorkspace=w.name())
else:
aggregate_flux = None
if self._flux_normalization_type == 'Proton Charge':
aggregate_flux = w.getRun().getProtonCharge()
elif self._flux_normalization_type == 'Duration':
aggregate_flux = w.getRun().getProperty('duration').value
w_nor = Scale(w,
Operation='Multiply',
Factor=1.0 / aggregate_flux,
OutputWorkspace=w.name())
return w_nor
