def testDetectorGrouping(self):
ws = illhelpers.create_poor_mans_in5_workspace(0.0,
_groupingTestDetectors)
originalNDetectors = ws.getNumberHistograms()
detectorIds = list()
for i in range(originalNDetectors):
detectorIds.append(ws.getDetector(i).getID())
_add_natural_angle_step_parameter(ws)
mtd.addOrReplace('inWS', ws)
outWSName = 'outWS'
algProperties = {
'InputWorkspace': ws,
'OutputWorkspace': outWSName,
'Cleanup': 'Cleanup OFF',
'Transposing': 'Transposing OFF',
'rethrow': True
}
run_algorithm('DirectILLReduction', **algProperties)
groupedWSName = outWSName + '_grouped_detectors_'
self.assertTrue(groupedWSName in mtd)
groupedWS = mtd[groupedWSName]
self.assertEqual(groupedWS.getNumberHistograms(), 2)
groupIds = list(groupedWS.getDetector(0).getDetectorIDs())
groupIds += groupedWS.getDetector(1).getDetectorIDs()
self.assertEqual(collections.Counter(detectorIds),
collections.Counter(groupIds))
def testDetectorGroupingWithUserGivenAngleStep(self):
ws = illhelpers.create_poor_mans_in5_workspace(0.0,
_groupingTestDetectors)
nhisto = ws.getNumberHistograms()
spectrumInfo = ws.spectrumInfo()
minAngle = 180.
maxAngle = 0.
for i in range(nhisto):
angle = numpy.rad2deg(spectrumInfo.twoTheta(i))
minAngle = min(minAngle, angle)
maxAngle = max(maxAngle, angle)
mtd.addOrReplace('inWS', ws)
outWSName = 'unused'
outSThetaWName = 'SofThetaW'
angleStep = 0.2
algProperties = {
'InputWorkspace': ws,
'OutputWorkspace': outWSName,
'GroupingAngleStep': angleStep,
'OutputSofThetaEnergyWorkspace': outSThetaWName,
'Transposing': 'Transposing OFF',
'rethrow': True
}
run_algorithm('DirectILLReduction', **algProperties)
self.assertTrue(outSThetaWName in mtd)
SThetaWWS = mtd[outSThetaWName]
spectrumInfo = SThetaWWS.spectrumInfo()
firstAngleBin = int(minAngle / angleStep)
lastAngleBin = int(maxAngle / angleStep) + 1
expected = lastAngleBin - firstAngleBin
self.assertEqual(spectrumInfo.size(), expected)
def testDetectorGroupingWithUserGivenAngleStep(self):
ws = illhelpers.create_poor_mans_in5_workspace(0.0, _groupingTestDetectors)
nhisto = ws.getNumberHistograms()
spectrumInfo = ws.spectrumInfo()
minAngle = 180.
maxAngle = 0.
for i in range(nhisto):
angle = numpy.rad2deg(spectrumInfo.twoTheta(i))
minAngle = min(minAngle, angle)
maxAngle = max(maxAngle, angle)
mtd.addOrReplace('inWS', ws)
outWSName = 'unused'
outSThetaWName = 'SofThetaW'
angleStep = 0.2
algProperties = {
'InputWorkspace': ws,
'OutputWorkspace': outWSName,
'GroupingAngleStep': angleStep,
'OutputSofThetaEnergyWorkspace': outSThetaWName,
'Transposing': 'Transposing OFF',
'rethrow': True
}
run_algorithm('DirectILLReduction', **algProperties)
self.assertTrue(outSThetaWName in mtd)
SThetaWWS = mtd[outSThetaWName]
spectrumInfo = SThetaWWS.spectrumInfo()
firstAngleBin = int(minAngle / angleStep)
lastAngleBin = int(maxAngle / angleStep) + 1
expected = lastAngleBin - firstAngleBin
self.assertEqual(spectrumInfo.size(), expected)
def test_TotScatCalculateSelfScattering_executes(self):
raw_ws = WorkspaceCreationHelper.create2DWorkspaceWithFullInstrument(6, 100, True)
mtd.addOrReplace("tot_scat_test", raw_ws)
correction_ws = TotScatCalculateSelfScattering(InputWorkspace="tot_scat_test",
CalFileName=self.cal_file_path,
SampleGeometry=self.geometry,
SampleMaterial=self.material)
self.assertEqual(correction_ws.getNumberHistograms(), 2)
def _cloneTestWorkspace(self, wsName=None):
if not wsName:
# Cannot use as default parameter as 'self' is not know in argument list.
wsName = self._TEST_WS_NAME
tempName = 'temp_testWS_'
mtd.addOrReplace(tempName, self._testIN5WS)
ws = CloneWorkspace(InputWorkspace=tempName, OutputWorkspace=wsName)
mtd.remove(tempName)
return ws
def _cloneTestWorkspace(self, wsName=None):
if not wsName:
# Cannot use as default parameter as 'self' is not know in argument list.
wsName = self._TEST_WS_NAME
tempName = 'temp_testWS_'
mtd.addOrReplace(tempName, self._testIN5WS)
ws = CloneWorkspace(InputWorkspace=tempName,
OutputWorkspace=wsName)
mtd.remove(tempName)
return ws
def setUp(self):
if DirectILLDiagnosticsTest._TEST_WS is None:
DirectILLDiagnosticsTest._TEST_WS = illhelpers.create_poor_mans_in5_workspace(self._BKG_LEVEL,
illhelpers.default_test_detectors)
inWSName = 'inputWS'
mtd.addOrReplace(inWSName, DirectILLDiagnosticsTest._TEST_WS)
kwargs = {
'InputWorkspace': DirectILLDiagnosticsTest._TEST_WS,
'OutputWorkspace': self._TEST_WS_NAME,
'EPPCreationMethod': 'Fit EPP',
'FlatBkg': 'Flat Bkg ON',
'OutputEPPWorkspace': self._EPP_WS_NAME,
'OutputRawWorkspace': self._RAW_WS_NAME
}
run_algorithm('DirectILLCollectData', **kwargs)
mtd.remove(inWSName)
def setUp(self):
if DirectILLDiagnosticsTest._TEST_WS is None:
DirectILLDiagnosticsTest._TEST_WS = illhelpers.create_poor_mans_in5_workspace(
self._BKG_LEVEL, illhelpers.default_test_detectors)
inWSName = 'inputWS'
mtd.addOrReplace(inWSName, DirectILLDiagnosticsTest._TEST_WS)
kwargs = {
'InputWorkspace': DirectILLDiagnosticsTest._TEST_WS,
'OutputWorkspace': self._TEST_WS_NAME,
'EPPCreationMethod': 'Fit EPP',
'FlatBkg': 'Flat Bkg ON',
'OutputEPPWorkspace': self._EPP_WS_NAME,
'OutputRawWorkspace': self._RAW_WS_NAME
}
run_algorithm('DirectILLCollectData', **kwargs)
mtd.remove(inWSName)
def testDetectorGrouping(self):
ws = illhelpers.create_poor_mans_in5_workspace(0.0, _groupingTestDetectors)
originalNDetectors = ws.getNumberHistograms()
detectorIds = list()
for i in range(originalNDetectors):
detectorIds.append(ws.getDetector(i).getID())
mtd.addOrReplace('inWS', ws)
outWSName = 'outWS'
algProperties = {
'InputWorkspace': ws,
'OutputWorkspace': outWSName,
'Cleanup': 'Cleanup OFF',
'Transposing': 'Transposing OFF',
'rethrow': True
}
run_algorithm('DirectILLReduction', **algProperties)
groupedWSName = outWSName + '_grouped_detectors_'
self.assertTrue(groupedWSName in mtd)
groupedWS = mtd[groupedWSName]
self.assertEqual(groupedWS.getNumberHistograms(), 1)
groupIds = groupedWS.getDetector(0).getDetectorIDs()
self.assertEqual(collections.Counter(detectorIds), collections.Counter(groupIds))
def setUp(self):
if not self._testIN5WS:
self._testIN5WS = illhelpers.create_poor_mans_in5_workspace(self._BKG_LEVEL,
illhelpers.default_test_detectors)
inWSName = 'inputWS'
mtd.addOrReplace(inWSName, self._testIN5WS)
kwargs = {
'InputWorkspace': self._testIN5WS,
'OutputWorkspace': self._TEST_WS_NAME,
'OutputEPPWorkspace': self._EPP_WS_NAME
}
run_algorithm('DirectILLCollectData', **kwargs)
kwargs = {
'InputWorkspace': self._TEST_WS_NAME,
'OutputWorkspace': self._VANADIUM_WS_NAME,
'EPPWorkspace': self._EPP_WS_NAME
}
run_algorithm('DirectILLIntegrateVanadium', **kwargs)
vanadiumWS = mtd[self._VANADIUM_WS_NAME]
for i in range(vanadiumWS.getNumberHistograms()):
vanadiumYs = vanadiumWS.dataY(i)
vanadiumYs.fill(1.0)
mtd.remove(inWSName)
def setUp(self):
if not self._testIN5WS:
self._testIN5WS = illhelpers.create_poor_mans_in5_workspace(
self._BKG_LEVEL, illhelpers.default_test_detectors)
inWSName = 'inputWS'
mtd.addOrReplace(inWSName, self._testIN5WS)
kwargs = {
'InputWorkspace': self._testIN5WS,
'OutputWorkspace': self._TEST_WS_NAME,
'OutputEPPWorkspace': self._EPP_WS_NAME
}
run_algorithm('DirectILLCollectData', **kwargs)
kwargs = {
'InputWorkspace': self._TEST_WS_NAME,
'OutputWorkspace': self._VANADIUM_WS_NAME,
'EPPWorkspace': self._EPP_WS_NAME
}
run_algorithm('DirectILLIntegrateVanadium', **kwargs)
vanadiumWS = mtd[self._VANADIUM_WS_NAME]
for i in range(vanadiumWS.getNumberHistograms()):
vanadiumYs = vanadiumWS.dataY(i)
vanadiumYs.fill(1.0)
mtd.remove(inWSName)
def PyExec(self):
# set up progress reporting
prog = Progress(self, 0, 1, 10)
prog.report('Converting to wavelength')
sample_wave_ws = self._convert_to_wavelength(self._sample_ws)
prog.report('Calculating sample absorption factors')
sample_kwargs = dict()
sample_kwargs.update(self._general_kwargs)
if self._set_sample_method == 'Chemical Formula':
sample_kwargs['ChemicalFormula'] = self._sample_chemical_formula
else:
sample_kwargs[
'CoherentXSection'] = self._sample_coherent_cross_section
sample_kwargs[
'IncoherentXSection'] = self._sample_incoherent_cross_section
sample_kwargs[
'AttenuationXSection'] = self._sample_attenuation_cross_section
sample_kwargs['DensityType'] = self._sample_density_type
sample_kwargs['Density'] = self._sample_density
if self._sample_density_type == 'Number Density':
sample_kwargs[
'NumberDensityUnit'] = self._sample_number_density_unit
sample_kwargs['Height'] = self._height
sample_kwargs['Shape'] = self._shape
if self._shape == 'FlatPlate':
sample_kwargs['Width'] = self._sample_width
sample_kwargs['Thickness'] = self._sample_thickness
sample_kwargs['Angle'] = self._sample_angle
sample_kwargs['Center'] = self._sample_center
if self._shape == 'Cylinder':
sample_kwargs['Radius'] = self._sample_radius
if self._shape == 'Annulus':
sample_kwargs['InnerRadius'] = self._sample_inner_radius
sample_kwargs['OuterRadius'] = self._sample_outer_radius
ss_monte_carlo_alg = self.createChildAlgorithm(
"SimpleShapeMonteCarloAbsorption", enableLogging=True)
ss_monte_carlo_alg.setProperty("InputWorkspace", sample_wave_ws)
self._set_algorithm_properties(ss_monte_carlo_alg, sample_kwargs)
ss_monte_carlo_alg.execute()
ass_ws = ss_monte_carlo_alg.getProperty("OutputWorkspace").value
sample_log_names = []
sample_log_values = []
for log_name, log_value in sample_kwargs.items():
sample_log_names.append("sample_" + log_name.lower())
sample_log_values.append(log_value)
ass_ws = self._convert_from_wavelength(ass_ws)
self._add_sample_log_multiple(ass_ws, sample_log_names,
sample_log_values)
if not self.isChild():
mtd.addOrReplace(self._ass_ws_name, ass_ws)
if self._container_ws:
prog.report('Calculating container absorption factors')
container_wave_1 = self._convert_to_wavelength(self._container_ws)
container_wave_2 = self._clone_ws(container_wave_1)
container_kwargs = dict()
container_kwargs.update(self._general_kwargs)
if self._set_can_method == 'Chemical Formula':
container_kwargs[
'ChemicalFormula'] = self._container_chemical_formula
else:
container_kwargs[
'CoherentXSection'] = self._container_coherent_cross_section
container_kwargs[
'IncoherentXSection'] = self._container_incoherent_cross_section
container_kwargs[
'AttenuationXSection'] = self._container_attenuation_cross_section
container_kwargs['DensityType'] = self._container_density_type
container_kwargs['Density'] = self._container_density
if self._container_density_type == 'Number Density':
container_kwargs[
'NumberDensityUnit'] = self._container_number_density_unit
container_kwargs['Height'] = self._height
container_kwargs['Shape'] = self._shape
self._set_algorithm_properties(ss_monte_carlo_alg,
container_kwargs)
if self._shape == 'FlatPlate':
offset_front = 0.5 * (self._container_front_thickness +
self._sample_thickness)
ss_monte_carlo_alg.setProperty("InputWorkspace",
container_wave_1)
ss_monte_carlo_alg.setProperty("Width", self._sample_width)
ss_monte_carlo_alg.setProperty("Angle", self._sample_angle)
ss_monte_carlo_alg.setProperty("Thickness",
self._container_front_thickness)
ss_monte_carlo_alg.setProperty("Center", -offset_front)
ss_monte_carlo_alg.execute()
acc_1 = ss_monte_carlo_alg.getProperty("OutputWorkspace").value
offset_back = 0.5 * (self._container_back_thickness +
self._sample_thickness)
ss_monte_carlo_alg.setProperty("InputWorkspace",
container_wave_2)
ss_monte_carlo_alg.setProperty("Thickness",
self._container_back_thickness)
ss_monte_carlo_alg.setProperty("Center", offset_back)
ss_monte_carlo_alg.execute()
acc_2 = ss_monte_carlo_alg.getProperty("OutputWorkspace").value
acc_ws = self._multiply(acc_1, acc_2)
elif self._shape == 'Cylinder':
ss_monte_carlo_alg.setProperty("InputWorkspace",
container_wave_1)
ss_monte_carlo_alg.setProperty("InnerRadius",
self._container_inner_radius)
ss_monte_carlo_alg.setProperty("OuterRadius",
self._container_outer_radius)
ss_monte_carlo_alg.setProperty("Shape", "Annulus")
ss_monte_carlo_alg.execute()
acc_ws = ss_monte_carlo_alg.getProperty(
"OutputWorkspace").value
elif self._shape == 'Annulus':
ss_monte_carlo_alg.setProperty("InputWorkspace",
container_wave_1)
ss_monte_carlo_alg.setProperty("InnerRadius",
self._container_inner_radius)
ss_monte_carlo_alg.setProperty("OuterRadius",
self._container_outer_radius)
ss_monte_carlo_alg.execute()
acc_1 = ss_monte_carlo_alg.getProperty("OutputWorkspace").value
ss_monte_carlo_alg.setProperty("InputWorkspace",
container_wave_2)
ss_monte_carlo_alg.execute()
acc_2 = ss_monte_carlo_alg.getProperty("OutputWorkspace").value
acc_ws = self._multiply(acc_1, acc_2)
for log_name, log_value in container_kwargs.items():
sample_log_names.append("container_" + log_name.lower())
sample_log_values.append(log_value)
acc_ws = self._convert_from_wavelength(acc_ws)
self._add_sample_log_multiple(acc_ws, sample_log_names,
sample_log_values)
if not self.isChild():
mtd.addOrReplace(self._acc_ws_name, acc_ws)
self._output_ws = self._group_ws([ass_ws, acc_ws])
else:
self._output_ws = self._group_ws([ass_ws])
self.setProperty('CorrectionsWorkspace', self._output_ws)
def setUp(self):
if not DirectILLCollectDataTest._TEST_WS:
DirectILLCollectDataTest._TEST_WS = illhelpers.create_poor_mans_in5_workspace(
self._BKG_LEVEL, illhelpers.default_test_detectors)
mtd.addOrReplace(self._TEST_WS_NAME, DirectILLCollectDataTest._TEST_WS)
def PyExec(self):
# set up progress reporting
prog = Progress(self, 0, 1, 10)
prog.report('Converting to wavelength')
sample_wave_ws = self._convert_to_wavelength(self._sample_ws)
prog.report('Calculating sample absorption factors')
sample_kwargs = dict()
sample_kwargs.update(self._general_kwargs)
sample_kwargs['ChemicalFormula'] = self._sample_chemical_formula
sample_kwargs['DensityType'] = self._sample_density_type
sample_kwargs['Density'] = self._sample_density
sample_kwargs['Height'] = self._height
sample_kwargs['Shape'] = self._shape
if self._shape == 'FlatPlate':
sample_kwargs['Width'] = self._sample_width
sample_kwargs['Thickness'] = self._sample_thickness
sample_kwargs['Angle'] = self._sample_angle
sample_kwargs['Center'] = self._sample_center
if self._shape == 'Cylinder':
sample_kwargs['Radius'] = self._sample_radius
if self._shape == 'Annulus':
sample_kwargs['InnerRadius'] = self._sample_inner_radius
sample_kwargs['OuterRadius'] = self._sample_outer_radius
ss_monte_carlo_alg = self.createChildAlgorithm("SimpleShapeMonteCarloAbsorption", enableLogging=True)
ss_monte_carlo_alg.setProperty("InputWorkspace", sample_wave_ws)
self._set_algorithm_properties(ss_monte_carlo_alg, sample_kwargs)
ss_monte_carlo_alg.execute()
ass_ws = ss_monte_carlo_alg.getProperty("OutputWorkspace").value
sample_log_names = []
sample_log_values = []
for log_name, log_value in sample_kwargs.items():
sample_log_names.append("sample_" + log_name.lower())
sample_log_values.append(log_value)
ass_ws = self._convert_from_wavelength(ass_ws)
self._add_sample_log_multiple(ass_ws, sample_log_names, sample_log_values)
if not self.isChild():
mtd.addOrReplace(self._ass_ws_name, ass_ws)
if self._container_ws:
prog.report('Calculating container absorption factors')
container_wave_1 = self._convert_to_wavelength(self._container_ws)
container_wave_2 = self._clone_ws(container_wave_1)
container_kwargs = dict()
container_kwargs.update(self._general_kwargs)
container_kwargs['ChemicalFormula'] = self._container_chemical_formula
container_kwargs['DensityType'] = self._container_density_type
container_kwargs['Density'] = self._container_density
container_kwargs['Height'] = self._height
container_kwargs['Shape'] = self._shape
self._set_algorithm_properties(ss_monte_carlo_alg, container_kwargs)
if self._shape == 'FlatPlate':
offset_front = 0.5 * (self._container_front_thickness + self._sample_thickness)
ss_monte_carlo_alg.setProperty("InputWorkspace", container_wave_1)
ss_monte_carlo_alg.setProperty("Width", self._sample_width)
ss_monte_carlo_alg.setProperty("Angle", self._sample_angle)
ss_monte_carlo_alg.setProperty("Thickness", self._container_front_thickness)
ss_monte_carlo_alg.setProperty("Center", -offset_front)
ss_monte_carlo_alg.execute()
acc_1 = ss_monte_carlo_alg.getProperty("OutputWorkspace").value
offset_back = 0.5 * (self._container_back_thickness + self._sample_thickness)
ss_monte_carlo_alg.setProperty("InputWorkspace", container_wave_2)
ss_monte_carlo_alg.setProperty("Thickness", self._container_back_thickness)
ss_monte_carlo_alg.setProperty("Center", offset_back)
ss_monte_carlo_alg.execute()
acc_2 = ss_monte_carlo_alg.getProperty("OutputWorkspace").value
acc_ws = self._multiply(acc_1, acc_2)
elif self._shape == 'Cylinder':
ss_monte_carlo_alg.setProperty("InputWorkspace", container_wave_1)
ss_monte_carlo_alg.setProperty("InnerRadius", self._container_inner_radius)
ss_monte_carlo_alg.setProperty("OuterRadius", self._container_outer_radius)
ss_monte_carlo_alg.setProperty("Shape", "Annulus")
ss_monte_carlo_alg.execute()
acc_ws = ss_monte_carlo_alg.getProperty("OutputWorkspace").value
elif self._shape == 'Annulus':
ss_monte_carlo_alg.setProperty("InputWorkspace", container_wave_1)
ss_monte_carlo_alg.setProperty("InnerRadius", self._container_inner_radius)
ss_monte_carlo_alg.setProperty("OuterRadius", self._container_outer_radius)
ss_monte_carlo_alg.execute()
acc_1 = ss_monte_carlo_alg.getProperty("OutputWorkspace").value
ss_monte_carlo_alg.setProperty("InputWorkspace", container_wave_2)
ss_monte_carlo_alg.execute()
acc_2 = ss_monte_carlo_alg.getProperty("OutputWorkspace").value
acc_ws = self._multiply(acc_1, acc_2)
for log_name, log_value in container_kwargs.items():
sample_log_names.append("container_" + log_name.lower())
sample_log_values.append(log_value)
acc_ws = self._convert_from_wavelength(acc_ws)
self._add_sample_log_multiple(acc_ws, sample_log_names, sample_log_values)
if not self.isChild():
mtd.addOrReplace(self._acc_ws_name, acc_ws)
self._output_ws = self._group_ws([ass_ws, acc_ws])
else:
self._output_ws = self._group_ws([ass_ws])
self.setProperty('CorrectionsWorkspace', self._output_ws)
def PyExec(self):
# Set up progress reporting
n_prog_reports = 2
if self._can_ws_name is not None:
n_prog_reports += 1
prog = Progress(self, 0.0, 1.0, n_prog_reports)
sample_wave_ws = '__sam_wave'
convert_unit_alg = self.createChildAlgorithm("ConvertUnits",
enableLogging=False)
convert_unit_alg.setProperty("InputWorkspace", self._sample_ws_name)
convert_unit_alg.setProperty("OutputWorkspace", sample_wave_ws)
convert_unit_alg.setProperty("Target", 'Wavelength')
convert_unit_alg.setProperty("EMode", self._emode)
convert_unit_alg.setProperty("EFixed", self._efixed)
convert_unit_alg.execute()
mtd.addOrReplace(sample_wave_ws,
convert_unit_alg.getProperty("OutputWorkspace").value)
prog.report('Calculating sample corrections')
SetBeam(sample_wave_ws,
Geometry={
'Shape': 'Slit',
'Width': self._beam_width,
'Height': self._beam_height
})
if self._sample_density_type == 'Mass Density':
sample_mat_list = {
'ChemicalFormula': self._sample_chemical_formula,
'SampleMassDensity': self._sample_density
}
if self._sample_density_type == 'Number Density':
sample_mat_list = {
'ChemicalFormula': self._sample_chemical_formula,
'SampleNumberDensity': self._sample_density
}
SetSample(sample_wave_ws,
Geometry={
'Shape': 'Cylinder',
'Height': self._sample_height,
'Radius': self._sample_radius,
'Center': [0., 0., 0.]
},
Material=sample_mat_list)
prog.report('Calculating sample corrections')
MonteCarloAbsorption(InputWorkspace=sample_wave_ws,
OutputWorkspace=self._ass_ws,
EventsPerPoint=self._events,
NumberOfWavelengthPoints=self._number_wavelengths,
Interpolation='CSpline')
group = self._ass_ws
delete_alg = self.createChildAlgorithm("DeleteWorkspace",
enableLogging=False)
divide_alg = self.createChildAlgorithm("Divide", enableLogging=False)
minus_alg = self.createChildAlgorithm("Minus", enableLogging=False)
if self._can_ws_name is not None:
can_wave_ws = '__can_wave'
convert_unit_alg.setProperty("InputWorkspace", self._can_ws_name)
convert_unit_alg.setProperty("OutputWorkspace", can_wave_ws)
convert_unit_alg.setProperty("Target", 'Wavelength')
convert_unit_alg.setProperty("EMode", self._emode)
convert_unit_alg.setProperty("EFixed", self._efixed)
convert_unit_alg.execute()
mtd.addOrReplace(
can_wave_ws,
convert_unit_alg.getProperty("OutputWorkspace").value)
if self._can_scale != 1.0:
logger.information('Scaling can by: %s' % self._can_scale)
scale_alg = self.createChildAlgorithm("Scale",
enableLogging=False)
scale_alg.setProperty("InputWorkspace", can_wave_ws)
scale_alg.setProperty("OutputWorkspace", can_wave_ws)
scale_alg.setProperty("Factor", self._can_scale)
scale_alg.setProperty("Operation", 'Multiply')
scale_alg.execute()
can_thickness = self._can_radius - self._sample_radius
logger.information('Container thickness: ' + str(can_thickness))
if self._use_can_corrections:
# Doing can corrections
prog.report('Calculating container corrections')
divide_alg.setProperty("LHSWorkspace", sample_wave_ws)
divide_alg.setProperty("RHSWorkspace", self._ass_ws)
divide_alg.setProperty("OutputWorkspace", sample_wave_ws)
divide_alg.execute()
if self._sample_density_type == 'Mass Density':
container_mat_list = {
'ChemicalFormula': self._can_chemical_formula,
'SampleMassDensity': self._can_density
}
if self._sample_density_type == 'Number Density':
container_mat_list = {
'ChemicalFormula': self._can_chemical_formula,
'SampleNumberDensity': self._can_density
}
SetSample(can_wave_ws,
Geometry={
'Shape': 'HollowCylinder',
'Height': self._sample_height,
'InnerRadius': self._sample_radius,
'OuterRadius': self._can_radius,
'Center': [0., 0., 0.]
},
Material=container_mat_list)
MonteCarloAbsorption(
InputWorkspace=can_wave_ws,
OutputWorkspace=self._acc_ws,
EventsPerPoint=self._events,
NumberOfWavelengthPoints=self._number_wavelengths,
Interpolation='CSpline')
divide_alg.setProperty("LHSWorkspace", can_wave_ws)
divide_alg.setProperty("RHSWorkspace", self._acc_ws)
divide_alg.setProperty("OutputWorkspace", can_wave_ws)
divide_alg.execute()
minus_alg.setProperty("LHSWorkspace", sample_wave_ws)
minus_alg.setProperty("RHSWorkspace", can_wave_ws)
minus_alg.setProperty("OutputWorkspace", sample_wave_ws)
minus_alg.execute()
group += ',' + self._acc_ws
else:
# Doing simple can subtraction
prog.report('Calculating container scaling')
minus_alg.setProperty("LHSWorkspace", sample_wave_ws)
minus_alg.setProperty("RHSWorkspace", can_wave_ws)
minus_alg.setProperty("OutputWorkspace", sample_wave_ws)
minus_alg.execute()
divide_alg.setProperty("LHSWorkspace", sample_wave_ws)
divide_alg.setProperty("RHSWorkspace", self._ass_ws)
divide_alg.setProperty("OutputWorkspace", sample_wave_ws)
divide_alg.execute()
delete_alg.setProperty("Workspace", can_wave_ws)
delete_alg.execute()
else:
divide_alg.setProperty("LHSWorkspace", sample_wave_ws)
divide_alg.setProperty("RHSWorkspace", self._ass_ws)
divide_alg.setProperty("OutputWorkspace", sample_wave_ws)
divide_alg.execute()
convert_unit_alg.setProperty("InputWorkspace", sample_wave_ws)
convert_unit_alg.setProperty("OutputWorkspace", self._output_ws)
convert_unit_alg.setProperty("Target", 'DeltaE')
convert_unit_alg.setProperty("EMode", self._emode)
convert_unit_alg.setProperty("EFixed", self._efixed)
convert_unit_alg.execute()
mtd.addOrReplace(self._output_ws,
convert_unit_alg.getProperty("OutputWorkspace").value)
delete_alg.setProperty("Workspace", sample_wave_ws)
delete_alg.execute()
# Record sample logs
prog.report('Recording sample logs')
sample_log_workspaces = [self._output_ws, self._ass_ws]
sample_logs = [('sample_shape', 'cylinder'),
('sample_filename', self._sample_ws_name),
('sample_radius', self._sample_radius)]
if self._can_ws_name is not None:
sample_logs.append(('container_filename', self._can_ws_name))
sample_logs.append(('container_scale', self._can_scale))
if self._use_can_corrections:
sample_log_workspaces.append(self._acc_ws)
sample_logs.append(('container_thickness', can_thickness))
log_names = [item[0] for item in sample_logs]
log_values = [item[1] for item in sample_logs]
add_sample_log_alg = self.createChildAlgorithm("AddSampleLogMultiple",
enableLogging=False)
for ws_name in sample_log_workspaces:
add_sample_log_alg.setProperty("Workspace", ws_name)
add_sample_log_alg.setProperty("LogNames", log_names)
add_sample_log_alg.setProperty("LogValues", log_values)
add_sample_log_alg.execute()
self.setProperty('OutputWorkspace', self._output_ws)
# Output the Abs group workspace if it is wanted, delete if not
if self._abs_ws == '':
delete_alg.setProperty("Workspace", self._ass_ws)
delete_alg.execute()
if self._can_ws_name is not None and self._use_can_corrections:
delete_alg.setProperty("Workspace", self._acc_ws)
delete_alg.execute()
else:
GroupWorkspaces(InputWorkspaces=group,
OutputWorkspace=self._abs_ws,
EnableLogging=False)
self.setProperty('CorrectionsWorkspace', self._abs_ws)
def PyExec(self): # noqa C901
inWS = self.getProperty("InputWorkspace").value
normWS = self.getProperty("NormalisationWorkspace").value
_norm = bool(normWS)
instrument = inWS.getExperimentInfo(0).getInstrument().getName()
dim0_min, dim0_max, dim0_bins = self.getProperty('BinningDim0').value
dim1_min, dim1_max, dim1_bins = self.getProperty('BinningDim1').value
dim2_min, dim2_max, dim2_bins = self.getProperty('BinningDim2').value
dim0_bins = int(dim0_bins)
dim1_bins = int(dim1_bins)
dim2_bins = int(dim2_bins)
dim0_bin_size = (dim0_max - dim0_min) / dim0_bins
dim1_bin_size = (dim1_max - dim1_min) / dim1_bins
dim2_bin_size = (dim2_max - dim2_min) / dim2_bins
data_array = inWS.getSignalArray(
) # getSignalArray returns a F_CONTIGUOUS view of the signal array
number_of_runs = data_array.shape[2]
progress = Progress(self, 0.0, 1.0, number_of_runs + 4)
# Get rotation array
if instrument == "HB3A":
omega = np.deg2rad(
inWS.getExperimentInfo(0).run().getProperty('omega').value)
chi = np.deg2rad(
inWS.getExperimentInfo(0).run().getProperty('chi').value)
phi = np.deg2rad(
inWS.getExperimentInfo(0).run().getProperty('phi').value)
else:
s1 = np.deg2rad(
inWS.getExperimentInfo(0).run().getProperty('s1').value
) + np.deg2rad(self.getProperty("S1Offset").value)
normaliseBy = self.getProperty("NormaliseBy").value
if normaliseBy == "Monitor":
if instrument == "HB3A":
scale = np.asarray(
inWS.getExperimentInfo(0).run().getProperty(
'monitor').value)
else:
scale = np.asarray(
inWS.getExperimentInfo(0).run().getProperty(
'monitor_count').value)
elif normaliseBy == "Time":
if instrument == "HB3A":
scale = np.asarray(
inWS.getExperimentInfo(0).run().getProperty('time').value)
else:
scale = np.asarray(
inWS.getExperimentInfo(0).run().getProperty(
'duration').value)
else:
scale = np.ones(number_of_runs)
if _norm:
if normaliseBy == "Monitor":
if instrument == "HB3A":
norm_scale = np.sum(
normWS.getExperimentInfo(0).run().getProperty(
'monitor').value)
else:
norm_scale = np.sum(
normWS.getExperimentInfo(0).run().getProperty(
'monitor_count').value)
elif normaliseBy == "Time":
if instrument == "HB3A":
norm_scale = np.sum(
normWS.getExperimentInfo(0).run().getProperty(
'time').value)
else:
norm_scale = np.sum(
normWS.getExperimentInfo(0).run().getProperty(
'duration').value)
else:
norm_scale = 1.
norm_array = normWS.getSignalArray().sum(axis=2)
W = np.eye(3)
UBW = np.eye(3)
if self.getProperty("Frame").value == 'HKL':
W[:, 0] = self.getProperty('Uproj').value
W[:, 1] = self.getProperty('Vproj').value
W[:, 2] = self.getProperty('Wproj').value
ubWS = self.getProperty("UBWorkspace").value
if ubWS:
try:
ol = ubWS.sample().getOrientedLattice()
except AttributeError:
ol = ubWS.getExperimentInfo(
0).sample().getOrientedLattice()
logger.notice("Using UB matrix from {} with {}".format(
ubWS.name(), ol))
else:
ol = inWS.getExperimentInfo(0).sample().getOrientedLattice()
logger.notice("Using UB matrix from {} with {}".format(
inWS.name(), ol))
UB = ol.getUB()
UBW = np.dot(UB, W)
char_dict = {0: '0', 1: '{1}', -1: '-{1}'}
chars = ['H', 'K', 'L']
names = [
'[' + ','.join(
char_dict.get(j, '{0}{1}').format(
j, chars[np.argmax(np.abs(W[:, i]))])
for j in W[:, i]) + ']' for i in range(3)
]
units = 'in {:.3f} A^-1,in {:.3f} A^-1,in {:.3f} A^-1'.format(
ol.qFromHKL(W[0]).norm(),
ol.qFromHKL(W[1]).norm(),
ol.qFromHKL(W[2]).norm())
frames = 'HKL,HKL,HKL'
k = 1 / self.getProperty(
"Wavelength"
).value # Not 2pi/wavelength to save dividing by 2pi later
else:
names = 'Q_sample_x,Q_sample_y,Q_sample_z'
units = 'Angstrom^-1,Angstrom^-1,Angstrom^-1'
frames = 'QSample,QSample,QSample'
k = 2 * np.pi / self.getProperty("Wavelength").value
progress.report('Calculating Qlab for each pixel')
if inWS.getExperimentInfo(0).run().hasProperty('twotheta'):
polar = np.array(
inWS.getExperimentInfo(0).run().getProperty('twotheta').value)
else:
di = inWS.getExperimentInfo(0).detectorInfo()
polar = np.array([
di.twoTheta(i) for i in range(di.size()) if not di.isMonitor(i)
])
if inWS.getExperimentInfo(0).getInstrument().getName() == 'HB3A':
polar = polar.reshape(512 * 3, 512).T.flatten()
if inWS.getExperimentInfo(0).run().hasProperty('twotheta'):
azim = np.array(
inWS.getExperimentInfo(0).run().getProperty('azimuthal').value)
else:
di = inWS.getExperimentInfo(0).detectorInfo()
azim = np.array([
di.azimuthal(i) for i in range(di.size())
if not di.isMonitor(i)
])
if inWS.getExperimentInfo(0).getInstrument().getName() == 'HB3A':
azim = azim.reshape(512 * 3, 512).T.flatten()
qlab = np.vstack(
(np.sin(polar) * np.cos(azim), np.sin(polar) * np.sin(azim),
np.cos(polar) - 1)).T * -k # Kf - Ki(0,0,1)
progress.report('Calculating Q volume')
output = np.zeros((dim0_bins + 2, dim1_bins + 2, dim2_bins + 2))
outputr = output.ravel()
output_scale = np.zeros_like(output)
output_scaler = output_scale.ravel()
if _norm:
output_norm = np.zeros_like(output)
output_normr = output_norm.ravel()
output_norm_scale = np.zeros_like(output)
output_norm_scaler = output_norm_scale.ravel()
bin_size = np.array([[dim0_bin_size], [dim1_bin_size],
[dim2_bin_size]])
offset = np.array([[dim0_min / dim0_bin_size],
[dim1_min / dim1_bin_size],
[dim2_min / dim2_bin_size]]) - 0.5
assert not data_array[:, :, 0].flags.owndata
assert not data_array[:, :, 0].ravel('F').flags.owndata
assert data_array[:, :, 0].flags.fnc
for n in range(number_of_runs):
if instrument == "HB3A":
R1 = np.array([
[np.cos(omega[n]), 0, -np.sin(omega[n])], # omega 0,1,0,-1
[0, 1, 0],
[np.sin(omega[n]), 0,
np.cos(omega[n])]
])
R2 = np.array([
[np.cos(chi[n]), np.sin(chi[n]), 0], # chi 0,0,1,-1
[-np.sin(chi[n]), np.cos(chi[n]), 0],
[0, 0, 1]
])
R3 = np.array([
[np.cos(phi[n]), 0, -np.sin(phi[n])], # phi 0,1,0,-1
[0, 1, 0],
[np.sin(phi[n]), 0, np.cos(phi[n])]
])
R = np.dot(np.dot(R1, R2), R3)
else:
R = np.array([
[np.cos(s1[n]), 0, np.sin(s1[n])], # s1 0,1,0,1
[0, 1, 0],
[-np.sin(s1[n]), 0, np.cos(s1[n])]
])
RUBW = np.dot(R, UBW)
q = np.round(
np.dot(np.linalg.inv(RUBW), qlab.T) / bin_size -
offset).astype(np.int)
q_index = np.ravel_multi_index(
q, (dim0_bins + 2, dim1_bins + 2, dim2_bins + 2), mode='clip')
q_uniq, inverse = np.unique(q_index, return_inverse=True)
outputr[q_uniq] += np.bincount(inverse, data_array[:, :,
n].ravel('F'))
output_scaler[q_uniq] += np.bincount(inverse) * scale[n]
if _norm:
output_normr[q_uniq] += np.bincount(inverse,
norm_array.ravel('F'))
output_norm_scaler[q_uniq] += np.bincount(inverse)
progress.report()
if _norm:
output *= output_norm_scale * norm_scale
output_norm *= output_scale
else:
output_norm = output_scale
if self.getProperty('KeepTemporaryWorkspaces').value:
# Create data workspace
progress.report('Creating data MDHistoWorkspace')
createWS_alg = self.createChildAlgorithm("CreateMDHistoWorkspace",
enableLogging=False)
createWS_alg.setProperty("SignalInput", output[1:-1, 1:-1,
1:-1].ravel('F'))
createWS_alg.setProperty(
"ErrorInput", np.sqrt(output[1:-1, 1:-1, 1:-1].ravel('F')))
createWS_alg.setProperty("Dimensionality", 3)
createWS_alg.setProperty(
"Extents",
'{},{},{},{},{},{}'.format(dim0_min, dim0_max, dim1_min,
dim1_max, dim2_min, dim2_max))
createWS_alg.setProperty(
"NumberOfBins", '{},{},{}'.format(dim0_bins, dim1_bins,
dim2_bins))
createWS_alg.setProperty("Names", names)
createWS_alg.setProperty("Units", units)
createWS_alg.setProperty("Frames", frames)
createWS_alg.execute()
outWS_data = createWS_alg.getProperty("OutputWorkspace").value
mtd.addOrReplace(
self.getPropertyValue("OutputWorkspace") + '_data', outWS_data)
# Create normalisation workspace
progress.report('Creating norm MDHistoWorkspace')
createWS_alg = self.createChildAlgorithm("CreateMDHistoWorkspace",
enableLogging=False)
createWS_alg.setProperty("SignalInput",
output_norm[1:-1, 1:-1, 1:-1].ravel('F'))
createWS_alg.setProperty(
"ErrorInput", np.sqrt(output_norm[1:-1, 1:-1,
1:-1].ravel('F')))
createWS_alg.setProperty("Dimensionality", 3)
createWS_alg.setProperty(
"Extents",
'{},{},{},{},{},{}'.format(dim0_min, dim0_max, dim1_min,
dim1_max, dim2_min, dim2_max))
createWS_alg.setProperty(
"NumberOfBins", '{},{},{}'.format(dim0_bins, dim1_bins,
dim2_bins))
createWS_alg.setProperty("Names", names)
createWS_alg.setProperty("Units", units)
createWS_alg.setProperty("Frames", frames)
createWS_alg.execute()
mtd.addOrReplace(
self.getPropertyValue("OutputWorkspace") + '_normalization',
createWS_alg.getProperty("OutputWorkspace").value)
old_settings = np.seterr(
divide='ignore', invalid='ignore'
) # Ignore RuntimeWarning: invalid value encountered in true_divide
output /= output_norm # We often divide by zero here and we get NaN's, this is desired behaviour
np.seterr(**old_settings)
progress.report('Creating MDHistoWorkspace')
createWS_alg = self.createChildAlgorithm("CreateMDHistoWorkspace",
enableLogging=False)
createWS_alg.setProperty("SignalInput", output[1:-1, 1:-1,
1:-1].ravel('F'))
createWS_alg.setProperty("ErrorInput",
np.sqrt(output[1:-1, 1:-1, 1:-1].ravel('F')))
createWS_alg.setProperty("Dimensionality", 3)
createWS_alg.setProperty(
"Extents",
'{},{},{},{},{},{}'.format(dim0_min, dim0_max, dim1_min, dim1_max,
dim2_min, dim2_max))
createWS_alg.setProperty(
"NumberOfBins", '{},{},{}'.format(dim0_bins, dim1_bins, dim2_bins))
createWS_alg.setProperty("Names", names)
createWS_alg.setProperty("Units", units)
createWS_alg.setProperty("Frames", frames)
createWS_alg.execute()
outWS = createWS_alg.getProperty("OutputWorkspace").value
# Copy experiment infos
if inWS.getNumExperimentInfo() > 0:
outWS.copyExperimentInfos(inWS)
outWS.getExperimentInfo(0).run().addProperty('RUBW_MATRIX',
list(UBW.flatten()), True)
outWS.getExperimentInfo(0).run().addProperty('W_MATRIX',
list(W.flatten()), True)
try:
if outWS.getExperimentInfo(0).sample().hasOrientedLattice():
outWS.getExperimentInfo(0).sample().getOrientedLattice().setUB(
UB)
except NameError:
pass
if self.getProperty('KeepTemporaryWorkspaces').value:
outWS_data.copyExperimentInfos(outWS)
progress.report()
self.setProperty("OutputWorkspace", outWS)
def PyExec(self):
inWS = self.getProperty("InputWorkspace").value
normWS = self.getProperty("NormalisationWorkspace").value
_norm = bool(normWS)
dim0_min, dim0_max, dim0_bins = self.getProperty('BinningDim0').value
dim1_min, dim1_max, dim1_bins = self.getProperty('BinningDim1').value
dim2_min, dim2_max, dim2_bins = self.getProperty('BinningDim2').value
dim0_bins = int(dim0_bins)
dim1_bins = int(dim1_bins)
dim2_bins = int(dim2_bins)
dim0_bin_size = (dim0_max-dim0_min)/dim0_bins
dim1_bin_size = (dim1_max-dim1_min)/dim1_bins
dim2_bin_size = (dim2_max-dim2_min)/dim2_bins
data_array = inWS.getSignalArray() # getSignalArray returns a F_CONTIGUOUS view of the signal array
number_of_runs = data_array.shape[2]
progress = Progress(self, 0.0, 1.0, number_of_runs+4)
# Get rotation array
s1 = np.deg2rad(inWS.getExperimentInfo(0).run().getProperty('s1').value) + np.deg2rad(self.getProperty("S1Offset").value)
normaliseBy = self.getProperty("NormaliseBy").value
if normaliseBy == "Monitor":
scale = np.asarray(inWS.getExperimentInfo(0).run().getProperty('monitor_count').value)
elif normaliseBy == "Time":
scale = np.asarray(inWS.getExperimentInfo(0).run().getProperty('duration').value)
else:
scale = np.ones(number_of_runs)
if _norm:
if normaliseBy == "Monitor":
norm_scale = np.sum(normWS.getExperimentInfo(0).run().getProperty('monitor_count').value)
elif normaliseBy == "Time":
norm_scale = np.sum(normWS.getExperimentInfo(0).run().getProperty('duration').value)
else:
norm_scale = 1.
norm_array = normWS.getSignalArray().sum(axis=2)
W = np.eye(3)
UBW = np.eye(3)
if self.getProperty("Frame").value == 'HKL':
W[:,0] = self.getProperty('Uproj').value
W[:,1] = self.getProperty('Vproj').value
W[:,2] = self.getProperty('Wproj').value
ubWS = self.getProperty("UBWorkspace").value
if ubWS:
try:
ol = ubWS.sample().getOrientedLattice()
except AttributeError:
ol = ubWS.getExperimentInfo(0).sample().getOrientedLattice()
logger.notice("Using UB matrix from {} with {}".format(ubWS.name(), ol))
else:
ol = inWS.getExperimentInfo(0).sample().getOrientedLattice()
logger.notice("Using UB matrix from {} with {}".format(inWS.name(), ol))
UB = ol.getUB()
UBW = np.dot(UB, W)
char_dict = {0:'0', 1:'{1}', -1:'-{1}'}
chars=['H','K','L']
names = ['['+','.join(char_dict.get(j, '{0}{1}')
.format(j,chars[np.argmax(np.abs(W[:,i]))]) for j in W[:,i])+']' for i in range(3)]
units = 'in {:.3f} A^-1,in {:.3f} A^-1,in {:.3f} A^-1'.format(ol.qFromHKL(W[0]).norm(),
ol.qFromHKL(W[1]).norm(),
ol.qFromHKL(W[2]).norm())
frames = 'HKL,HKL,HKL'
k = 1/self.getProperty("Wavelength").value # Not 2pi/wavelength to save dividing by 2pi later
else:
names = 'Q_sample_x,Q_sample_y,Q_sample_z'
units = 'Angstrom^-1,Angstrom^-1,Angstrom^-1'
frames = 'QSample,QSample,QSample'
k = 2*np.pi/self.getProperty("Wavelength").value
progress.report('Calculating Qlab for each pixel')
polar = np.array(inWS.getExperimentInfo(0).run().getProperty('twotheta').value)
azim = np.array(inWS.getExperimentInfo(0).run().getProperty('azimuthal').value)
qlab = np.vstack((np.sin(polar)*np.cos(azim),
np.sin(polar)*np.sin(azim),
np.cos(polar) - 1)).T * -k # Kf - Ki(0,0,1)
progress.report('Calculating Q volume')
output = np.zeros((dim0_bins+2, dim1_bins+2, dim2_bins+2))
outputr = output.ravel()
output_scale = np.zeros_like(output)
output_scaler = output_scale.ravel()
if _norm:
output_norm = np.zeros_like(output)
output_normr = output_norm.ravel()
output_norm_scale = np.zeros_like(output)
output_norm_scaler = output_norm_scale.ravel()
bin_size = np.array([[dim0_bin_size],
[dim1_bin_size],
[dim2_bin_size]])
offset = np.array([[dim0_min/dim0_bin_size],
[dim1_min/dim1_bin_size],
[dim2_min/dim2_bin_size]])-0.5
assert not data_array[:,:,0].flags.owndata
assert not data_array[:,:,0].ravel('F').flags.owndata
assert data_array[:,:,0].flags.fnc
for n in range(number_of_runs):
R = np.array([[ np.cos(s1[n]), 0, np.sin(s1[n])],
[ 0, 1, 0],
[-np.sin(s1[n]), 0, np.cos(s1[n])]])
RUBW = np.dot(R,UBW)
q = np.round(np.dot(np.linalg.inv(RUBW),qlab.T)/bin_size-offset).astype(np.int)
q_index = np.ravel_multi_index(q, (dim0_bins+2, dim1_bins+2, dim2_bins+2), mode='clip')
q_uniq, inverse = np.unique(q_index, return_inverse=True)
outputr[q_uniq] += np.bincount(inverse, data_array[:,:,n].ravel('F'))
output_scaler[q_uniq] += np.bincount(inverse)*scale[n]
if _norm:
output_normr[q_uniq] += np.bincount(inverse, norm_array.ravel('F'))
output_norm_scaler[q_uniq] += np.bincount(inverse)
progress.report()
if _norm:
output *= output_norm_scale*norm_scale
output_norm *= output_scale
else:
output_norm = output_scale
if self.getProperty('KeepTemporaryWorkspaces').value:
# Create data workspace
progress.report('Creating data MDHistoWorkspace')
createWS_alg = self.createChildAlgorithm("CreateMDHistoWorkspace", enableLogging=False)
createWS_alg.setProperty("SignalInput", output[1:-1,1:-1,1:-1].ravel('F'))
createWS_alg.setProperty("ErrorInput", np.sqrt(output[1:-1,1:-1,1:-1].ravel('F')))
createWS_alg.setProperty("Dimensionality", 3)
createWS_alg.setProperty("Extents", '{},{},{},{},{},{}'.format(dim0_min,dim0_max,dim1_min,dim1_max,dim2_min,dim2_max))
createWS_alg.setProperty("NumberOfBins", '{},{},{}'.format(dim0_bins,dim1_bins,dim2_bins))
createWS_alg.setProperty("Names", names)
createWS_alg.setProperty("Units", units)
createWS_alg.setProperty("Frames", frames)
createWS_alg.execute()
outWS_data = createWS_alg.getProperty("OutputWorkspace").value
mtd.addOrReplace(self.getPropertyValue("OutputWorkspace")+'_data', outWS_data)
# Create normalisation workspace
progress.report('Creating norm MDHistoWorkspace')
createWS_alg = self.createChildAlgorithm("CreateMDHistoWorkspace", enableLogging=False)
createWS_alg.setProperty("SignalInput", output_norm[1:-1,1:-1,1:-1].ravel('F'))
createWS_alg.setProperty("ErrorInput", np.sqrt(output_norm[1:-1,1:-1,1:-1].ravel('F')))
createWS_alg.setProperty("Dimensionality", 3)
createWS_alg.setProperty("Extents", '{},{},{},{},{},{}'.format(dim0_min,dim0_max,dim1_min,dim1_max,dim2_min,dim2_max))
createWS_alg.setProperty("NumberOfBins", '{},{},{}'.format(dim0_bins,dim1_bins,dim2_bins))
createWS_alg.setProperty("Names", names)
createWS_alg.setProperty("Units", units)
createWS_alg.setProperty("Frames", frames)
createWS_alg.execute()
mtd.addOrReplace(self.getPropertyValue("OutputWorkspace")+'_normalization', createWS_alg.getProperty("OutputWorkspace").value)
old_settings = np.seterr(divide='ignore', invalid='ignore') # Ignore RuntimeWarning: invalid value encountered in true_divide
output /= output_norm # We often divide by zero here and we get NaN's, this is desired behaviour
np.seterr(**old_settings)
progress.report('Creating MDHistoWorkspace')
createWS_alg = self.createChildAlgorithm("CreateMDHistoWorkspace", enableLogging=False)
createWS_alg.setProperty("SignalInput", output[1:-1,1:-1,1:-1].ravel('F'))
createWS_alg.setProperty("ErrorInput", np.sqrt(output[1:-1,1:-1,1:-1].ravel('F')))
createWS_alg.setProperty("Dimensionality", 3)
createWS_alg.setProperty("Extents", '{},{},{},{},{},{}'.format(dim0_min,dim0_max,dim1_min,dim1_max,dim2_min,dim2_max))
createWS_alg.setProperty("NumberOfBins", '{},{},{}'.format(dim0_bins,dim1_bins,dim2_bins))
createWS_alg.setProperty("Names", names)
createWS_alg.setProperty("Units", units)
createWS_alg.setProperty("Frames", frames)
createWS_alg.execute()
outWS = createWS_alg.getProperty("OutputWorkspace").value
# Copy experiment infos
if inWS.getNumExperimentInfo() > 0:
outWS.copyExperimentInfos(inWS)
outWS.getExperimentInfo(0).run().addProperty('RUBW_MATRIX', list(UBW.flatten()), True)
outWS.getExperimentInfo(0).run().addProperty('W_MATRIX', list(W.flatten()), True)
try:
if outWS.getExperimentInfo(0).sample().hasOrientedLattice():
outWS.getExperimentInfo(0).sample().getOrientedLattice().setUB(UB)
except NameError:
pass
if self.getProperty('KeepTemporaryWorkspaces').value:
outWS_data.copyExperimentInfos(outWS)
progress.report()
self.setProperty("OutputWorkspace", outWS)
def PyExec(self):
# Set up progress reporting
n_prog_reports = 2
if self._can_ws_name is not None:
n_prog_reports += 1
prog = Progress(self, 0.0, 1.0, n_prog_reports)
sample_wave_ws = '__sam_wave'
convert_unit_alg = self.createChildAlgorithm("ConvertUnits", enableLogging=False)
convert_unit_alg.setProperty("InputWorkspace", self._sample_ws_name)
convert_unit_alg.setProperty("OutputWorkspace", sample_wave_ws)
convert_unit_alg.setProperty("Target", 'Wavelength')
convert_unit_alg.setProperty("EMode", self._emode)
convert_unit_alg.setProperty("EFixed", self._efixed)
convert_unit_alg.execute()
mtd.addOrReplace(sample_wave_ws, convert_unit_alg.getProperty("OutputWorkspace").value)
prog.report('Calculating sample corrections')
SetBeam(sample_wave_ws,
Geometry={'Shape': 'Slit',
'Width': self._beam_width,
'Height': self._beam_height})
if self._sample_density_type == 'Mass Density':
sample_mat_list = {'ChemicalFormula': self._sample_chemical_formula,
'SampleMassDensity': self._sample_density}
if self._sample_density_type == 'Number Density':
sample_mat_list = {'ChemicalFormula': self._sample_chemical_formula,
'SampleNumberDensity': self._sample_density}
SetSample(sample_wave_ws,
Geometry={'Shape': 'Cylinder',
'Height': self._sample_height,
'Radius': self._sample_radius,
'Center': [0., 0., 0.]},
Material=sample_mat_list)
prog.report('Calculating sample corrections')
MonteCarloAbsorption(InputWorkspace=sample_wave_ws,
OutputWorkspace=self._ass_ws,
EventsPerPoint=self._events,
NumberOfWavelengthPoints=self._number_wavelengths,
Interpolation='CSpline')
group = self._ass_ws
delete_alg = self.createChildAlgorithm("DeleteWorkspace", enableLogging=False)
divide_alg = self.createChildAlgorithm("Divide", enableLogging=False)
minus_alg = self.createChildAlgorithm("Minus", enableLogging=False)
if self._can_ws_name is not None:
can_wave_ws = '__can_wave'
convert_unit_alg.setProperty("InputWorkspace", self._can_ws_name)
convert_unit_alg.setProperty("OutputWorkspace", can_wave_ws)
convert_unit_alg.setProperty("Target", 'Wavelength')
convert_unit_alg.setProperty("EMode", self._emode)
convert_unit_alg.setProperty("EFixed", self._efixed)
convert_unit_alg.execute()
mtd.addOrReplace(can_wave_ws, convert_unit_alg.getProperty("OutputWorkspace").value)
if self._can_scale != 1.0:
logger.information('Scaling can by: %s' % self._can_scale)
scale_alg = self.createChildAlgorithm("Scale", enableLogging=False)
scale_alg.setProperty("InputWorkspace", can_wave_ws)
scale_alg.setProperty("OutputWorkspace", can_wave_ws)
scale_alg.setProperty("Factor", self._can_scale)
scale_alg.setProperty("Operation", 'Multiply')
scale_alg.execute()
can_thickness = self._can_radius - self._sample_radius
logger.information('Container thickness: ' + str(can_thickness))
if self._use_can_corrections:
# Doing can corrections
prog.report('Calculating container corrections')
divide_alg.setProperty("LHSWorkspace", sample_wave_ws)
divide_alg.setProperty("RHSWorkspace", self._ass_ws)
divide_alg.setProperty("OutputWorkspace", sample_wave_ws)
divide_alg.execute()
if self._sample_density_type == 'Mass Density':
container_mat_list = {'ChemicalFormula': self._can_chemical_formula,
'SampleMassDensity': self._can_density}
if self._sample_density_type == 'Number Density':
container_mat_list = {'ChemicalFormula': self._can_chemical_formula,
'SampleNumberDensity': self._can_density}
SetSample(can_wave_ws,
Geometry={'Shape': 'HollowCylinder',
'Height': self._sample_height,
'InnerRadius': self._sample_radius,
'OuterRadius': self._can_radius,
'Center': [0., 0., 0.]},
Material=container_mat_list)
MonteCarloAbsorption(InputWorkspace=can_wave_ws,
OutputWorkspace=self._acc_ws,
EventsPerPoint=self._events,
NumberOfWavelengthPoints=self._number_wavelengths,
Interpolation='CSpline')
divide_alg.setProperty("LHSWorkspace", can_wave_ws)
divide_alg.setProperty("RHSWorkspace", self._acc_ws)
divide_alg.setProperty("OutputWorkspace", can_wave_ws)
divide_alg.execute()
minus_alg.setProperty("LHSWorkspace", sample_wave_ws)
minus_alg.setProperty("RHSWorkspace", can_wave_ws)
minus_alg.setProperty("OutputWorkspace", sample_wave_ws)
minus_alg.execute()
group += ',' + self._acc_ws
else:
# Doing simple can subtraction
prog.report('Calculating container scaling')
minus_alg.setProperty("LHSWorkspace", sample_wave_ws)
minus_alg.setProperty("RHSWorkspace", can_wave_ws)
minus_alg.setProperty("OutputWorkspace", sample_wave_ws)
minus_alg.execute()
divide_alg.setProperty("LHSWorkspace", sample_wave_ws)
divide_alg.setProperty("RHSWorkspace", self._ass_ws)
divide_alg.setProperty("OutputWorkspace", sample_wave_ws)
divide_alg.execute()
delete_alg.setProperty("Workspace", can_wave_ws)
delete_alg.execute()
else:
divide_alg.setProperty("LHSWorkspace", sample_wave_ws)
divide_alg.setProperty("RHSWorkspace", self._ass_ws)
divide_alg.setProperty("OutputWorkspace", sample_wave_ws)
divide_alg.execute()
convert_unit_alg.setProperty("InputWorkspace", sample_wave_ws)
convert_unit_alg.setProperty("OutputWorkspace", self._output_ws)
convert_unit_alg.setProperty("Target", 'DeltaE')
convert_unit_alg.setProperty("EMode", self._emode)
convert_unit_alg.setProperty("EFixed", self._efixed)
convert_unit_alg.execute()
mtd.addOrReplace(self._output_ws, convert_unit_alg.getProperty("OutputWorkspace").value)
delete_alg.setProperty("Workspace", sample_wave_ws)
delete_alg.execute()
# Record sample logs
prog.report('Recording sample logs')
sample_log_workspaces = [self._output_ws, self._ass_ws]
sample_logs = [('sample_shape', 'cylinder'),
('sample_filename', self._sample_ws_name),
('sample_radius', self._sample_radius)]
if self._can_ws_name is not None:
sample_logs.append(('container_filename', self._can_ws_name))
sample_logs.append(('container_scale', self._can_scale))
if self._use_can_corrections:
sample_log_workspaces.append(self._acc_ws)
sample_logs.append(('container_thickness', can_thickness))
log_names = [item[0] for item in sample_logs]
log_values = [item[1] for item in sample_logs]
add_sample_log_alg = self.createChildAlgorithm("AddSampleLogMultiple", enableLogging=False)
for ws_name in sample_log_workspaces:
add_sample_log_alg.setProperty("Workspace", ws_name)
add_sample_log_alg.setProperty("LogNames", log_names)
add_sample_log_alg.setProperty("LogValues", log_values)
add_sample_log_alg.execute()
self.setProperty('OutputWorkspace', self._output_ws)
# Output the Abs group workspace if it is wanted, delete if not
if self._abs_ws == '':
delete_alg.setProperty("Workspace", self._ass_ws)
delete_alg.execute()
if self._can_ws_name is not None and self._use_can_corrections:
delete_alg.setProperty("Workspace", self._acc_ws)
delete_alg.execute()
else:
GroupWorkspaces(InputWorkspaces=group,
OutputWorkspace=self._abs_ws,
EnableLogging=False)
self.setProperty('CorrectionsWorkspace', self._abs_ws)
def setUp(self):
if not DirectILLCollectDataTest._TEST_WS:
DirectILLCollectDataTest._TEST_WS = illhelpers.create_poor_mans_in5_workspace(self._BKG_LEVEL,
illhelpers.default_test_detectors)
mtd.addOrReplace(self._TEST_WS_NAME, DirectILLCollectDataTest._TEST_WS)
