def convertToElasticQ(input_ws, output_ws=None):
"""
Helper function to convert the spectrum axis of a sample to ElasticQ.
@param input_ws - the name of the workspace to convert from
@param output_ws - the name to call the converted workspace
"""
if output_ws is None:
output_ws = input_ws
axis = mtd[input_ws].getAxis(1)
if axis.isSpectra():
e_fixed = getEfixed(input_ws)
ConvertSpectrumAxis(input_ws,Target='ElasticQ',EMode='Indirect',EFixed=e_fixed,OutputWorkspace=output_ws)
elif axis.isNumeric():
#check that units are Momentum Transfer
if axis.getUnit().unitID() != 'MomentumTransfer':
logger.error('Input must have axis values of Q')
sys.exit()
CloneWorkspace(input_ws, OutputWorkspace=output_ws)
else:
logger.error('Input workspace must have either spectra or numeric axis.')
sys.exit()
def PyExec(self):
from mantid import logger
from IndirectCommon import StartTime, EndTime
self._setup()
StartTime('CreateCalibrationWorkspace')
runs = []
for in_file in self._input_files:
(_, filename) = os.path.split(in_file)
(root, _) = os.path.splitext(filename)
try:
Load(Filename=in_file,
OutputWorkspace=root,
SpectrumMin=int(self._spec_range[0]),
SpectrumMax=int(self._spec_range[1]),
LoadLogFiles=False)
runs.append(root)
except Exception as exc:
logger.error('Could not load raw file "%s": %s' %
(in_file, str(exc)))
calib_ws_name = 'calibration'
if len(runs) > 1:
MergeRuns(InputWorkspaces=",".join(runs),
OutputWorkspace=calib_ws_name)
factor = 1.0 / len(runs)
Scale(InputWorkspace=calib_ws_name,
OutputWorkspace=calib_ws_name,
Factor=factor)
else:
calib_ws_name = runs[0]
CalculateFlatBackground(InputWorkspace=calib_ws_name,
OutputWorkspace=calib_ws_name,
StartX=self._back_range[0],
EndX=self._back_range[1],
Mode='Mean')
from inelastic_indirect_reduction_steps import NormaliseToUnityStep
ntu = NormaliseToUnityStep()
ntu.set_factor(self._intensity_scale)
ntu.set_peak_range(self._peak_range[0], self._peak_range[1])
ntu.execute(None, calib_ws_name)
RenameWorkspace(InputWorkspace=calib_ws_name,
OutputWorkspace=self._out_ws)
# Remove old workspaces
if len(runs) > 1:
for run in runs:
DeleteWorkspace(Workspace=run)
self.setProperty('OutputWorkspace', self._out_ws)
self._post_process()
EndTime('CreateCalibrationWorkspace')
def validateParams(self):
'''Check parameters are positive'''
height = self.getParameterValue('height')
tau = self.getParameterValue('tau')
beta = self.getParameterValue('beta')
for name,value in {'height':height, 'tau':tau, 'beta':beta}.items():
if value <=0:
message = 'Parameter {} in StretchedExpFT must be positive. Got {} instead'.format(name, str(value))
logger.error(message)
#raise ValueError(message)
return None
return {'height':height, 'tau':tau, 'beta':beta}
def validateParams(self):
'''Check parameters within expected range'''
intensity = self.getParameterValue('Intensity')
if intensity <=0:
message = 'Parameter Intensity in DSFinterp1DFit must be positive. Got {0} instead'.format(intensity)
logger.error(message)
return None
f = self.getParameterValue('TargetParameter')
if f < self._fmin or f > self._fmax:
message = 'TargetParameter {0} is out of bounds [{1}, {2}]. Applying penalty...'.format(f, self._fmin, self._fmax)
logger.error(message)
return None
return {'Intensity':intensity, 'TargetParameter':f}
def validateParams(self):
"""Check parameters are positive"""
height = self.getParameterValue('height')
tau = self.getParameterValue('tau')
beta = self.getParameterValue('beta')
origin = self.getParameterValue('Origin')
for name, value in {'height': height, 'tau': tau, 'beta': beta}.items():
if value <= 0:
message = 'Parameter {} in StretchedExpFT must be positive. Got {} instead'.format(name, str(value))
logger.error(message)
# raise ValueError(message)
return None
return {'height': height, 'tau': tau, 'beta': beta, 'Origin': origin}
def validateParams(self):
"""Check parameters are positive"""
height = self.getParameterValue("height")
tau = self.getParameterValue("tau")
beta = self.getParameterValue("beta")
origin = self.getParameterValue("Origin")
for name, value in {"height": height, "tau": tau, "beta": beta}.items():
if value <= 0:
message = "Parameter {} in StretchedExpFT must be positive. Got {} instead".format(name, str(value))
logger.error(message)
# raise ValueError(message)
return None
return {"height": height, "tau": tau, "beta": beta, "Origin": origin}
def validateParams(self):
'''Check parameters within expected range'''
intensity = self.getParameterValue('Intensity')
if intensity <= 0:
message = 'Parameter Intensity in DSFinterp1DFit must be positive. Got {0} instead'.format(
intensity)
logger.error(message)
return None
f = self.getParameterValue('TargetParameter')
if f < self._fmin or f > self._fmax:
message = 'TargetParameter {0} is out of bounds [{1}, {2}]. Applying penalty...'.format(
f, self._fmin, self._fmax)
logger.error(message)
return None
return {'Intensity': intensity, 'TargetParameter': f}
def ReadMap(path):
asc = loadFile(path)
lasc = len(asc)
logger.information('Map file : ' + path + ' ; spectra = ' + str(lasc - 1))
val = ExtractInt(asc[0])
numb = val[0]
if numb != (lasc - 1):
error = 'Number of lines not equal to number of spectra'
logger.error(error)
sys.exit(error)
map = []
for n in range(1, lasc):
val = ExtractInt(asc[n])
map.append(val[1])
return map
def ReadMap(path):
asc = loadFile(path)
lasc = len(asc)
logger.information('Map file : ' + path + ' ; spectra = ' + str(lasc - 1))
val = ExtractInt(asc[0])
numb = val[0]
if numb != (lasc - 1):
error = 'Number of lines not equal to number of spectra'
logger.error(error)
sys.exit(error)
map = []
for n in range(1, lasc):
val = ExtractInt(asc[n])
map.append(val[1])
return map
def resolution(files, iconOpt, rebinParam, bground,
instrument, analyser, reflection,
Res=True, factor=None, Plot=False, Verbose=False, Save=False):
reducer = inelastic_indirect_reducer.IndirectReducer()
reducer.set_instrument_name(instrument)
reducer.set_detector_range(iconOpt['first']-1,iconOpt['last']-1)
for file in files:
reducer.append_data_file(file)
parfile = instrument +"_"+ analyser +"_"+ reflection +"_Parameters.xml"
reducer.set_parameter_file(parfile)
reducer.set_grouping_policy('All')
reducer.set_sum_files(True)
try:
reducer.reduce()
except Exception, e:
logger.error(str(e))
return
def function1D(self, xvals):
''' Fit using the interpolated structure factor '''
p=self.validateParams()
if not p:
return numpy.zeros(len(xvals), dtype=float) # return zeros if parameters not valid
# The first time the function is called requires initialization of the interpolator
if self._channelgroup is None:
# Check consistency of the input
# check InputWorkspaces have at least the workspace index
for w in self._InputWorkspaces:
if mtd[w].getNumberHistograms() <= self._WorkspaceIndex:
message = 'Numer of histograms in Workspace {0} does not allow for workspace index {1}'.format(w,self._WorkspaceIndex)
logger.error(message)
raise IndexError(message)
# check number of input workspaces and parameters is the same
if len(self._ParameterValues) != len(self._InputWorkspaces):
message = 'Number of InputWorkspaces and ParameterValues should be the same.'+\
' Found {0} and {1}, respectively'.format(len(self._InputWorkspaces), len(self._ParameterValues))
logger.error(message)
raise ValueError(message)
# check the regression type is valid
if self._RegressionType not in self._RegressionTypes:
message = 'Regression type {0} not implemented. choose one of {1}'.format(self._RegressionType,
', '.join(self._RegressionTypes))
logger.error(message)
raise NotImplementedError(message)
# check the regression window is appropriate for the regression type selected
if self._RegressionWindow < self._minWindow[self._RegressionType]:
message = 'RegressionWindow must be equal or bigger than '+\
'{0} for regression type {1}'.format(self._minWindow[self._RegressionType], self._RegressionType)
logger.error(message)
raise ValueError(message)
# Initialize the energies of the channels with the first of the input workspaces
self._xvalues = numpy.copy( mtd[ self._InputWorkspaces[0] ].dataX(self._WorkspaceIndex) )
if len(self._xvalues) == 1+ len( mtd[ self._InputWorkspaces[0] ].dataY(self._WorkspaceIndex) ):
self._xvalues = (self._xvalues[1:]+self._xvalues[:-1])/2.0 # Deal with histogram data
# Initialize the channel group
nf = len(self._ParameterValues)
# Load the InputWorkspaces into a group of dynamic structure factors
from dsfinterp.dsf import Dsf
from dsfinterp.dsfgroup import DsfGroup
dsfgroup = DsfGroup()
for idsf in range(nf):
dsf = Dsf()
dsf.SetIntensities( mtd[ self._InputWorkspaces[idsf] ].dataY(self._WorkspaceIndex) )
dsf.errors = None # do not incorporate error data
if self._LoadErrors:
dsf.SetErrors(mtd[ self._InputWorkspaces[idsf] ].dataE(self._WorkspaceIndex))
dsf.SetFvalue( self._ParameterValues[idsf] )
dsfgroup.InsertDsf(dsf)
# Create the interpolator
from dsfinterp.channelgroup import ChannelGroup
self._channelgroup = ChannelGroup()
self._channelgroup.InitFromDsfGroup(dsfgroup)
if self._LocalRegression:
self._channelgroup.InitializeInterpolator(running_regr_type=self._RegressionType, windowlength=self._RegressionWindow)
else:
self._channelgroup.InitializeInterpolator(windowlength=0)
# channel group has been initialized, so evaluate the interpolator
dsf = self._channelgroup(p['TargetParameter'])
# Linear interpolation between the energies of the channels and the xvalues we require
# NOTE: interpolator evaluates to zero for any of the xvals outside of the domain defined by self._xvalues
intensities_interpolator = scipy.interpolate.interp1d(self._xvalues, p['Intensity']*dsf.intensities, kind='linear')
return intensities_interpolator(xvals) # can we pass by reference?
def PyExec(self):
from mantid import config, logger
from IndirectCommon import StartTime, EndTime
import inelastic_indirect_reducer
self._setup()
StartTime('InelasticIndirectReduction')
# Setup reducer
reducer = inelastic_indirect_reducer.IndirectReducer()
reducer.set_rename(True)
reducer.set_instrument_name(self._instrument)
reducer.set_parameter_file(self._param_file)
try:
reducer.set_output_path(config["defaultsave.directory"])
except RuntimeError:
pass # Use default
for data_file in self._data_files:
reducer.append_data_file(data_file)
reducer.set_sum_files(self._sum_files)
reducer.set_detector_range(int(self._detector_range[0]) - 1, int(self._detector_range[1]) - 1)
self._use_calib_ws = self._calib_ws_name != ''
if self._use_calib_ws:
logger.information('Using calibration workspace: %s' % self._calib_ws_name)
reducer.set_calibration_workspace(self._calib_ws_name)
if len(self._background_range) == 2:
logger.debug('Using background range: ' + str(self._background_range))
reducer.set_background(float(self._background_range[0]), float(self._background_range[1]))
# TODO: There should be a better way to do this
self._use_detailed_balance = self._detailed_balance != -1.0
if self._use_detailed_balance:
logger.debug('Using detailed balance: ' + str(self._detailed_balance))
reducer.set_detailed_balance(self._detailed_balance)
if self._rebin_string != '':
logger.debug('Using rebin string: ' + self._rebin_string)
reducer.set_rebin_string(self._rebin_string)
self._use_scale_factor = self._scale_factor != 1.0
if self._use_scale_factor:
logger.debug('Using scale factor: ' + str(self._scale_factor))
reducer.set_scale_factor(self._scale_factor)
if self._map_file != '':
logger.debug('Using mapping file: ' + str(self._map_file))
reducer.set_grouping_policy(self._map_file)
reducer.set_fold_multiple_frames(self.getProperty('Fold').value)
reducer.set_save_to_cm_1(self.getProperty('SaveCM1').value)
reducer.set_save_formats(self._save_formats)
# Do reduction and get result workspaces
reducer.reduce()
ws_list = reducer.get_result_workspaces()
self._plot_ws = ws_list[0]
if len(ws_list) < 1:
logger.error('Failed to complete reduction')
return
# Add sample logs to output workspace(s)
for workspace in ws_list:
self._add_ws_logs(workspace)
# Group output workspaces
GroupWorkspaces(InputWorkspaces=ws_list, OutputWorkspace=self._out_ws_group)
self.setProperty('OutputWorkspace', self._out_ws_group)
# Do plotting
if self._plot_type != 'none':
self._plot()
EndTime('InelasticIndirectReduction')
def unsupported_message():
logger.error(
'F2Py functionality not currently available on your platform.')
sys.exit()
if ystart==ystop or xstart==xstop:
X,Y=np.meshgrid(xvals,yvals)
plt.pcolormesh(X,Y,arrayToPlot,shading='gouraud')
else:
arrayToPlot_trim = arrayToPlot[xstart:xstop, ystart:ystop]
Y,X=np.meshgrid(yvals[ystart:ystop],xvals[xstart:xstop])
normmasked=np.ma.masked_where(arrayToPlot_trim==0,arrayToPlot_trim)
plt.pcolormesh(X,Y,normmasked,shading='gouraud')
plt.xlabel(dim0.getName())
plt.ylabel(dim1.getName())
plt.title(dim2.getName()+' integrated from '+"{0:.3f}".format(d2min)+' to '+"{0:.3f}".format(d2max))
if __name__ == "__main__":
# check number of arguments
if (len(sys.argv) != 3):
logger.error("autoreduction code requires a filename and an output directory")
sys.exit()
if not(os.path.isfile(sys.argv[1])):
logger.error("data file "+sys.argv[1]+ " not found")
sys.exit()
else:
filename = sys.argv[1]
outdir = sys.argv[2]
nexus_file=sys.argv[1]
output_directory=sys.argv[2]
output_file=os.path.split(nexus_file)[-1].replace('.nxs.h5','')
# load file
raw=Load(nexus_file)
# Do the cross-correlation and save the file
def unsupported_message():
logger.error(UNSUPPORTED_PLATFORM_MESSAGE)
sys.exit()
def unsupported_message():
logger.error('F2Py functionality not currently available on your platform.')
sys.exit()
else:
arrayToPlot_trim = arrayToPlot[xstart:xstop, ystart:ystop]
Y, X = np.meshgrid(yvals[ystart:ystop], xvals[xstart:xstop])
normmasked = np.ma.masked_where(arrayToPlot_trim == 0,
arrayToPlot_trim)
plt.pcolormesh(X, Y, normmasked, shading='gouraud')
plt.xlabel(dim0.getName())
plt.ylabel(dim1.getName())
plt.title(dim2.getName() + ' integrated from ' + "{:.3f}".format(d2min) +
' to ' + "{:.3f}".format(d2max))
if __name__ == "__main__":
# check number of arguments
if (len(sys.argv) != 3):
logger.error(
"autoreduction code requires a filename and an output directory")
sys.exit()
if not (os.path.isfile(sys.argv[1])):
logger.error("data file " + sys.argv[1] + " not found")
sys.exit()
else:
filename = sys.argv[1]
outdir = sys.argv[2]
nexus_file = sys.argv[1]
output_directory = sys.argv[2]
output_file = os.path.split(nexus_file)[-1].replace('.nxs.h5', '')
# load file
raw = Load(nexus_file)
# Do the cross-correlation and save the file.
def function1D(self, xvals):
''' Fit using the interpolated structure factor '''
p = self.validateParams()
if not p:
return numpy.zeros(
len(xvals),
dtype=float) # return zeros if parameters not valid
# The first time the function is called requires initialization of the interpolator
if self._channelgroup is None:
# Check consistency of the input
# check InputWorkspaces have at least the workspace index
for w in self._InputWorkspaces:
if mtd[w].getNumberHistograms() <= self._WorkspaceIndex:
message = 'Numer of histograms in Workspace {0} does not allow for workspace index {1}'.format(
w, self._WorkspaceIndex)
logger.error(message)
raise IndexError(message)
# check number of input workspaces and parameters is the same
if len(self._ParameterValues) != len(self._InputWorkspaces):
message = 'Number of InputWorkspaces and ParameterValues should be the same.'+\
' Found {0} and {1}, respectively'.format(len(self._InputWorkspaces), len(self._ParameterValues))
logger.error(message)
raise ValueError(message)
# check the regression type is valid
if self._RegressionType not in self._RegressionTypes:
message = 'Regression type {0} not implemented. choose one of {1}'.format(
self._RegressionType, ', '.join(self._RegressionTypes))
logger.error(message)
raise NotImplementedError(message)
# check the regression window is appropriate for the regression type selected
if self._RegressionWindow < self._minWindow[self._RegressionType]:
message = 'RegressionWindow must be equal or bigger than '+\
'{0} for regression type {1}'.format(self._minWindow[self._RegressionType], self._RegressionType)
logger.error(message)
raise ValueError(message)
# Initialize the energies of the channels with the first of the input workspaces
self._xvalues = numpy.copy(mtd[self._InputWorkspaces[0]].dataX(
self._WorkspaceIndex))
if len(self._xvalues) == 1 + len(
mtd[self._InputWorkspaces[0]].dataY(self._WorkspaceIndex)):
self._xvalues = (self._xvalues[1:] + self._xvalues[:-1]
) / 2.0 # Deal with histogram data
# Initialize the channel group
nf = len(self._ParameterValues)
# Load the InputWorkspaces into a group of dynamic structure factors
from dsfinterp.dsf import Dsf
from dsfinterp.dsfgroup import DsfGroup
dsfgroup = DsfGroup()
for idsf in range(nf):
dsf = Dsf()
dsf.SetIntensities(mtd[self._InputWorkspaces[idsf]].dataY(
self._WorkspaceIndex))
dsf.errors = None # do not incorporate error data
if self._LoadErrors:
dsf.SetErrors(mtd[self._InputWorkspaces[idsf]].dataE(
self._WorkspaceIndex))
dsf.SetFvalue(self._ParameterValues[idsf])
dsfgroup.InsertDsf(dsf)
# Create the interpolator
from dsfinterp.channelgroup import ChannelGroup
self._channelgroup = ChannelGroup()
self._channelgroup.InitFromDsfGroup(dsfgroup)
if self._LocalRegression:
self._channelgroup.InitializeInterpolator(
running_regr_type=self._RegressionType,
windowlength=self._RegressionWindow)
else:
self._channelgroup.InitializeInterpolator(windowlength=0)
# channel group has been initialized, so evaluate the interpolator
dsf = self._channelgroup(p['TargetParameter'])
# Linear interpolation between the energies of the channels and the xvalues we require
# NOTE: interpolator evaluates to zero for any of the xvals outside of the domain defined by self._xvalues
intensities_interpolator = scipy.interpolate.interp1d(self._xvalues,
p['Intensity'] *
dsf.intensities,
kind='linear')
return intensities_interpolator(xvals) # can we pass by reference?
