diff --git a/Framework/Beamline/inc/MantidBeamline/DetectorInfo.h b/Framework/Beamline/inc/MantidBeamline/DetectorInfo.h
index 195c63623f08b4c5f39307310a091357bb4b020b..cc83265ab5dab7a246b249db9378277f9ddf6d29 100644
--- a/Framework/Beamline/inc/MantidBeamline/DetectorInfo.h
+++ b/Framework/Beamline/inc/MantidBeamline/DetectorInfo.h
@@ -67,6 +67,7 @@ public:
bool isMasked(const std::pair<size_t, size_t> &index) const;
void setMasked(const size_t index, bool masked);
void setMasked(const std::pair<size_t, size_t> &index, bool masked);
+ bool hasMaskedDetectors() const;
Eigen::Vector3d position(const size_t index) const;
Eigen::Vector3d position(const std::pair<size_t, size_t> &index) const;
Eigen::Quaterniond rotation(const size_t index) const;
@@ -211,6 +212,12 @@ DetectorInfo::linearIndex(const std::pair<size_t, size_t> &index) const {
return index.first + size() * index.second;
}
+/// Returns if there are masked detectors
+inline bool DetectorInfo::hasMaskedDetectors() const {
+ return std::any_of(m_isMasked->cbegin(), m_isMasked->cend(),
+ [](const auto flag) { return flag; });
+}
+
} // namespace Beamline
} // namespace Mantid
diff --git a/Framework/DataHandling/src/LoadILLSANS.cpp b/Framework/DataHandling/src/LoadILLSANS.cpp
index c5fba0cf62b9836f65c46b69e0fad25bfafb4a79..f5af0252b8bbbf53b914ea9e0db52833b75464b1 100644
--- a/Framework/DataHandling/src/LoadILLSANS.cpp
+++ b/Framework/DataHandling/src/LoadILLSANS.cpp
@@ -604,6 +604,8 @@ void LoadILLSANS::loadMetaData(const NeXus::NXEntry &entry,
double wavelength =
entry.getFloat(instrumentNamePath + "/selector/wavelength");
g_log.debug() << "Wavelength found in the nexus file: " << wavelength << '\n';
+ // round the wavelength to avoid unnecessary rebinning during merge runs
+ wavelength = std::round(wavelength * 100) / 100.;
if (wavelength <= 0) {
g_log.debug() << "Mode = " << entry.getFloat("mode") << '\n';
@@ -625,6 +627,9 @@ void LoadILLSANS::loadMetaData(const NeXus::NXEntry &entry,
g_log.warning("Could not find wavelength resolution, assuming 10%");
}
}
+ // round also the wavelength res to avoid unnecessary rebinning during merge
+ // runs
+ wavelengthRes = std::round(wavelengthRes * 100) / 100.;
runDetails.addProperty<double>("wavelength", wavelength);
double ei = m_loader.calculateEnergy(wavelength);
runDetails.addProperty<double>("Ei", ei, true);
diff --git a/Framework/DataHandling/test/LoadILLSANSTest.h b/Framework/DataHandling/test/LoadILLSANSTest.h
index 9a1ac3be4e06773f722eca6b5cdd0aa7b017b2a8..18245958d944a1457f127489e2c3522c414c8e20 100644
--- a/Framework/DataHandling/test/LoadILLSANSTest.h
+++ b/Framework/DataHandling/test/LoadILLSANSTest.h
@@ -87,8 +87,8 @@ public:
const auto &spec6 = outputWS->y(6).rawData();
const auto &err6 = outputWS->e(6).rawData();
TS_ASSERT_EQUALS(xAxis.size(), 2)
- TS_ASSERT_DELTA(xAxis[0], 5.72778, 1E-5)
- TS_ASSERT_DELTA(xAxis[1], 6.26757, 1E-5)
+ TS_ASSERT_DELTA(xAxis[0], 5.73, 1E-5)
+ TS_ASSERT_DELTA(xAxis[1], 6.27, 1E-5)
TS_ASSERT_EQUALS(spec6[0], 20)
TS_ASSERT_DELTA(err6[0], sqrt(20), 1E-5)
const auto unit = outputWS->getAxis(0)->unit()->unitID();
@@ -122,8 +122,8 @@ public:
const auto &spec6 = outputWS->y(6).rawData();
const auto &err6 = outputWS->e(6).rawData();
TS_ASSERT_EQUALS(xAxis.size(), 2)
- TS_ASSERT_DELTA(xAxis[0], 4.75015, 1E-5)
- TS_ASSERT_DELTA(xAxis[1], 5.25016, 1E-5)
+ TS_ASSERT_DELTA(xAxis[0], 4.75, 1E-5)
+ TS_ASSERT_DELTA(xAxis[1], 5.25, 1E-5)
TS_ASSERT_EQUALS(spec6[0], 45)
TS_ASSERT_DELTA(err6[0], sqrt(45), 1E-5)
const auto unit = outputWS->getAxis(0)->unit()->unitID();
diff --git a/Framework/Geometry/inc/MantidGeometry/Instrument/DetectorInfo.h b/Framework/Geometry/inc/MantidGeometry/Instrument/DetectorInfo.h
index 42fd010d5a4bea049e31f2bc136d0d45be7205a2..d4ed8d5001e68e8c94e2db602876fc5642c52956 100644
--- a/Framework/Geometry/inc/MantidGeometry/Instrument/DetectorInfo.h
+++ b/Framework/Geometry/inc/MantidGeometry/Instrument/DetectorInfo.h
@@ -68,6 +68,7 @@ public:
bool isMonitor(const std::pair<size_t, size_t> &index) const;
bool isMasked(const size_t index) const;
bool isMasked(const std::pair<size_t, size_t> &index) const;
+ bool hasMaskedDetectors() const;
double l2(const size_t index) const;
double l2(const std::pair<size_t, size_t> &index) const;
double twoTheta(const size_t index) const;
diff --git a/Framework/Geometry/src/Instrument/DetectorInfo.cpp b/Framework/Geometry/src/Instrument/DetectorInfo.cpp
index b830abdb47a21bf75c9d5bafbe8a64ff9ece359e..82310bcef19ef256cf0c4d9cf77a37bcad23759f 100644
--- a/Framework/Geometry/src/Instrument/DetectorInfo.cpp
+++ b/Framework/Geometry/src/Instrument/DetectorInfo.cpp
@@ -111,6 +111,11 @@ bool DetectorInfo::isMasked(const std::pair<size_t, size_t> &index) const {
return m_detectorInfo->isMasked(index);
}
+/// Returns true if there are masked detectors
+bool DetectorInfo::hasMaskedDetectors() const {
+ return m_detectorInfo->hasMaskedDetectors();
+}
+
/** Returns L2 (distance from sample to spectrum).
*
* For monitors this is defined such that L1+L2 = source-detector distance,
diff --git a/Framework/PythonInterface/mantid/geometry/src/Exports/DetectorInfo.cpp b/Framework/PythonInterface/mantid/geometry/src/Exports/DetectorInfo.cpp
index 24511cce6d875bd35c3a02e15b352b2ca8d146c3..15279d5e9e01903927d69be9c0e89bee32038c1e 100644
--- a/Framework/PythonInterface/mantid/geometry/src/Exports/DetectorInfo.cpp
+++ b/Framework/PythonInterface/mantid/geometry/src/Exports/DetectorInfo.cpp
@@ -119,5 +119,7 @@ void export_DetectorInfo() {
.def("l2", l2, (arg("self"), arg("index")),
"Returns the l2 scattering distance")
.def("l1", &DetectorInfo::l1, arg("self"),
- "Returns the l1 scattering distance");
+ "Returns the l1 scattering distance")
+ .def("hasMaskedDetectors", &DetectorInfo::hasMaskedDetectors, arg("self"),
+ "Returns if there are masked detectors");
}
diff --git a/Framework/PythonInterface/plugins/algorithms/WorkflowAlgorithms/SANSILLAutoProcess.py b/Framework/PythonInterface/plugins/algorithms/WorkflowAlgorithms/SANSILLAutoProcess.py
new file mode 100644
index 0000000000000000000000000000000000000000..6c0987da7eb0ab3198febb800e551ab785885961
--- /dev/null
+++ b/Framework/PythonInterface/plugins/algorithms/WorkflowAlgorithms/SANSILLAutoProcess.py
@@ -0,0 +1,484 @@
+# Mantid Repository : https://github.com/mantidproject/mantid
+#
+# Copyright © 2018 ISIS Rutherford Appleton Laboratory UKRI,
+# NScD Oak Ridge National Laboratory, European Spallation Source
+# & Institut Laue - Langevin
+# SPDX - License - Identifier: GPL - 3.0 +
+from __future__ import (absolute_import, division, print_function)
+
+from mantid.api import *
+from mantid.kernel import *
+from mantid.simpleapi import *
+from os import path
+
+
+EMPTY_TOKEN = '000000'
+
+
+def needs_loading(property_value, loading_reduction_type):
+ """
+ Checks whether a given unary input needs loading or is already loaded in ADS.
+ @param property_value : the string value of the corresponding FileProperty
+ @param loading_reduction_type : the reduction_type of input to load
+ """
+ loading = False
+ ws_name = ''
+ if property_value:
+ ws_name = path.splitext(path.basename(property_value))[0]
+ if mtd.doesExist(ws_name):
+ logger.notice('Reusing {0} workspace: {1}'.format(loading_reduction_type, ws_name))
+ else:
+ loading = True
+ return [loading, ws_name]
+
+
+def get_run_number(value):
+ """
+ Extracts the run number from the first run out of the string value of a multiple file property of numors
+ """
+ return path.splitext(path.basename(value.split(',')[0].split('+')[0]))[0]
+
+
+def needs_processing(property_value, process_reduction_type):
+ """
+ Checks whether a given unary reduction needs processing or is already cached in ADS with expected name.
+ @param property_value : the string value of the corresponding MultipleFile input property
+ @param process_reduction_type : the reduction_type of process
+ """
+ do_process = False
+ ws_name = ''
+ if property_value:
+ run_number = get_run_number(property_value)
+ ws_name = run_number + '_' + process_reduction_type
+ if mtd.doesExist(ws_name):
+ run = mtd[ws_name].getRun()
+ if run.hasProperty('ProcessedAs'):
+ process = run.getLogData('ProcessedAs').value
+ if process == process_reduction_type:
+ logger.notice('Reusing {0} workspace: {1}'.format(process_reduction_type, ws_name))
+ else:
+ logger.warning(
+ '{0} workspace found, but processed differently: {1}'.format(process_reduction_type, ws_name))
+ do_process = True
+ else:
+ logger.warning(
+ '{0} workspace found, but missing the ProcessedAs flag: {1}'.format(process_reduction_type, ws_name))
+ do_process = True
+ else:
+ do_process = True
+ return [do_process, ws_name]
+
+
+class SANSILLAutoProcess(DataProcessorAlgorithm):
+ """
+ Performs complete treatment of ILL SANS data; instruments D11, D22, D33.
+ """
+ progress = None
+ reduction_type = None
+ sample = None
+ absorber = None
+ beam = None
+ container = None
+ stransmission = None
+ ctransmission = None
+ btransmission = None
+ atransmission = None
+ sensitivity = None
+ mask = None
+ flux = None
+ default_mask = None
+ output = None
+ output_sens = None
+ dimensionality = None
+ reference = None
+ normalise = None
+ radius = None
+ thickness = None
+
+ def category(self):
+ return 'ILL\\SANS;ILL\\Auto'
+
+ def summary(self):
+ return 'Performs complete SANS data reduction at the ILL.'
+
+ def seeAlso(self):
+ return ['SANSILLReduction', 'SANSILLIntegration',]
+
+ def name(self):
+ return 'SANSILLAutoProcess'
+
+ def validateInputs(self):
+ result = dict()
+ message = 'Wrong number of {0} runs: {1}. Provide one or as many as sample runs: {2}.'
+ tr_message = 'Wrong number of {0} runs: {1}. Provide one or multiple runs summed with +.'
+ sample_dim = self.getPropertyValue('SampleRuns').count(',')
+ abs_dim = self.getPropertyValue('AbsorberRuns').count(',')
+ beam_dim = self.getPropertyValue('BeamRuns').count(',')
+ flux_dim = self.getPropertyValue('FluxRuns').count(',')
+ can_dim = self.getPropertyValue('ContainerRuns').count(',')
+ str_dim = self.getPropertyValue('SampleTransmissionRuns').count(',')
+ ctr_dim = self.getPropertyValue('ContainerTransmissionRuns').count(',')
+ btr_dim = self.getPropertyValue('TransmissionBeamRuns').count(',')
+ atr_dim = self.getPropertyValue('TransmissionAbsorberRuns').count(',')
+ mask_dim = self.getPropertyValue('MaskFiles').count(',')
+ sens_dim = self.getPropertyValue('SensitivityMaps').count(',')
+ ref_dim = self.getPropertyValue('ReferenceFiles').count(',')
+ if self.getPropertyValue('SampleRuns') == '':
+ result['SampleRuns'] = 'Please provide at least one sample run.'
+ if abs_dim != sample_dim and abs_dim != 0:
+ result['AbsorberRuns'] = message.format('Absorber', abs_dim, sample_dim)
+ if beam_dim != sample_dim and beam_dim != 0:
+ result['BeamRuns'] = message.format('Beam', beam_dim, sample_dim)
+ if can_dim != sample_dim and can_dim != 0:
+ result['ContainerRuns'] = message.format('Container', can_dim, sample_dim)
+ if str_dim != 0:
+ issues['SampleTransmissionRuns'] = tr_message.format('SampleTransmission', str_dim)
+ if ctr_dim != 0:
+ issues['ContainerTransmissionRuns'] = tr_message.format('ContainerTransmission', ctr_dim)
+ if btr_dim != 0:
+ issues['TransmissionBeamRuns'] = tr_message.format('TransmissionBeam', btr_dim)
+ if atr_dim != 0:
+ issues['TransmissionAbsorberRuns'] = tr_message.format('TransmissionAbsorber', atr_dim)
+ if mask_dim != sample_dim and mask_dim != 0:
+ result['MaskFiles'] = message.format('Mask', mask_dim, sample_dim)
+ if ref_dim != sample_dim and ref_dim != 0:
+ result['ReferenceFiles'] = message.format('Reference', ref_dim, sample_dim)
+ if sens_dim != sample_dim and sens_dim != 0:
+ result['SensitivityMaps'] = message.format('Sensitivity', sens_dim, sample_dim)
+ if flux_dim != flux_dim and flux_dim != 0:
+ result['FluxRuns'] = message.format('Flux')
+
+ return result
+
+ def setUp(self):
+ self.sample = self.getPropertyValue('SampleRuns').split(',')
+ self.absorber = self.getPropertyValue('AbsorberRuns').split(',')
+ self.beam = self.getPropertyValue('BeamRuns').split(',')
+ self.flux = self.getPropertyValue('FluxRuns').split(',')
+ self.container = self.getPropertyValue('ContainerRuns').split(',')
+ self.stransmission = self.getPropertyValue('SampleTransmissionRuns')
+ self.ctransmission = self.getPropertyValue('ContainerTransmissionRuns')
+ self.btransmission = self.getPropertyValue('TransmissionBeamRuns')
+ self.atransmission = self.getPropertyValue('TransmissionAbsorberRuns')
+ self.sensitivity = self.getPropertyValue('SensitivityMaps').split(',')
+ self.default_mask = self.getPropertyValue('DefaultMaskFile')
+ self.mask = self.getPropertyValue('MaskFiles').split(',')
+ self.reference = self.getPropertyValue('ReferenceFiles').split(',')
+ self.output = self.getPropertyValue('OutputWorkspace')
+ self.output_sens = self.getPropertyValue('SensitivityOutputWorkspace')
+ self.reduction_type = self.getPropertyValue('ReductionType')
+ self.normalise = self.getPropertyValue('NormaliseBy')
+ self.radius = self.getProperty('BeamRadius').value
+ self.dimensionality = len(self.sample)
+ self.progress = Progress(self, start=0.0, end=1.0, nreports=10 * self.dimensionality)
+
+ def PyInit(self):
+
+ self.declareProperty('ReductionType', defaultValue='ReduceSample',
+ validator=StringListValidator(['ReduceSample', 'ReduceWater']),
+ doc='Choose whether to treat a sample or a water run to calculate sensitivity.')
+
+ self.declareProperty(WorkspaceGroupProperty('OutputWorkspace', '',
+ direction=Direction.Output),
+ doc='The output workspace group containing reduced data.')
+
+ self.declareProperty(MultipleFileProperty('SampleRuns',
+ action=FileAction.OptionalLoad,
+ extensions=['nxs'],
+ allow_empty=True),
+ doc='Sample run(s).')
+
+ self.declareProperty(MultipleFileProperty('AbsorberRuns',
+ action=FileAction.OptionalLoad,
+ extensions=['nxs']),
+ doc='Absorber (Cd/B4C) run(s).')
+
+ self.declareProperty(MultipleFileProperty('BeamRuns',
+ action=FileAction.OptionalLoad,
+ extensions=['nxs']),
+ doc='Empty beam run(s).')
+
+ self.declareProperty(MultipleFileProperty('FluxRuns',
+ action=FileAction.OptionalLoad,
+ extensions=['nxs']),
+ doc='Empty beam run(s) for flux calculation only; '
+ 'if left blank flux will be calculated from BeamRuns.')
+
+ self.declareProperty(MultipleFileProperty('ContainerRuns',
+ action=FileAction.OptionalLoad,
+ extensions=['nxs']),
+ doc='Empty container run(s).')
+
+ self.setPropertyGroup('SampleRuns', 'Numors')
+ self.setPropertyGroup('AbsorberRuns', 'Numors')
+ self.setPropertyGroup('BeamRuns', 'Numors')
+ self.setPropertyGroup('FluxRuns', 'Numors')
+ self.setPropertyGroup('ContainerRuns', 'Numors')
+
+ self.declareProperty(MultipleFileProperty('SampleTransmissionRuns',
+ action=FileAction.OptionalLoad,
+ extensions=['nxs']),
+ doc='Sample transmission run(s).')
+
+ self.declareProperty(MultipleFileProperty('ContainerTransmissionRuns',
+ action=FileAction.OptionalLoad,
+ extensions=['nxs']),
+ doc='Container transmission run(s).')
+
+ self.declareProperty(MultipleFileProperty('TransmissionBeamRuns',
+ action=FileAction.OptionalLoad,
+ extensions=['nxs']),
+ doc='Empty beam run(s) for transmission.')
+
+ self.declareProperty(MultipleFileProperty('TransmissionAbsorberRuns',
+ action=FileAction.OptionalLoad,
+ extensions=['nxs']),
+ doc='Absorber (Cd/B4C) run(s) for transmission.')
+
+ self.setPropertyGroup('SampleTransmissionRuns', 'Transmissions')
+ self.setPropertyGroup('ContainerTransmissionRuns', 'Transmissions')
+ self.setPropertyGroup('TransmissionBeamRuns', 'Transmissions')
+ self.setPropertyGroup('TransmissionAbsorberRuns', 'Transmissions')
+
+ self.declareProperty(MultipleFileProperty('SensitivityMaps',
+ action=FileAction.OptionalLoad,
+ extensions=['nxs']),
+ doc='File(s) containing the map of relative detector efficiencies.')
+
+ self.declareProperty(FileProperty('DefaultMaskFile', '', action=FileAction.OptionalLoad, extensions=['nxs']),
+ doc='File containing the default mask to be applied to all the detector configurations.')
+
+ self.declareProperty(MultipleFileProperty('MaskFiles',
+ action=FileAction.OptionalLoad,
+ extensions=['nxs']),
+ doc='File(s) containing the beam stop and other detector mask.')
+
+ self.declareProperty(MultipleFileProperty('ReferenceFiles',
+ action=FileAction.OptionalLoad,
+ extensions=['nxs']),
+ doc='File(s) containing the corrected water data for absolute normalisation.')
+
+ self.declareProperty(MatrixWorkspaceProperty('SensitivityOutputWorkspace', '',
+ direction=Direction.Output,
+ optional=PropertyMode.Optional),
+ doc='The output sensitivity map workspace.')
+
+ self.copyProperties('SANSILLReduction',
+ ['NormaliseBy'])
+
+ self.declareProperty('SampleThickness', 0.1, validator=FloatBoundedValidator(lower=0.),
+ doc='Sample thickness [cm]')
+
+ self.declareProperty('BeamRadius', 0.05, validator=FloatBoundedValidator(lower=0.),
+ doc='Beam raduis [m]; used for beam center finding, transmission and flux calculations.')
+
+ self.declareProperty('WaterCrossSection', 1., doc='Provide water cross-section; '
+ 'used only if the absolute scale is done by dividing to water.')
+
+ self.setPropertyGroup('SensitivityMaps', 'Options')
+ self.setPropertyGroup('DefaultMaskFile', 'Options')
+ self.setPropertyGroup('MaskFiles', 'Options')
+ self.setPropertyGroup('ReferenceFiles', 'Options')
+ self.setPropertyGroup('SensitivityOutputWorkspace', 'Options')
+ self.setPropertyGroup('NormaliseBy', 'Options')
+ self.setPropertyGroup('SampleThickness', 'Options')
+ self.setPropertyGroup('BeamRadius', 'Options')
+ self.setPropertyGroup('WaterCrossSection', 'Options')
+
+ self.copyProperties('SANSILLIntegration',
+ ['OutputType', 'CalculateResolution', 'DefaultQBinning', 'BinningFactor', 'OutputBinning',
+ 'NPixelDivision', 'NumberOfWedges', 'WedgeWorkspace', 'WedgeAngle', 'WedgeOffset',
+ 'AsymmetricWedges', 'MaxQxy', 'DeltaQ', 'IQxQyLogBinning'])
+
+ self.setPropertyGroup('OutputType', 'Integration Options')
+ self.setPropertyGroup('CalculateResolution', 'Integration Options')
+
+ def PyExec(self):
+
+ self.setUp()
+ outputs = []
+ for i in range(self.dimensionality):
+ if self.sample[i] != EMPTY_TOKEN:
+ self.reduce(i)
+ outputs.append(self.output+'_'+str(i+1))
+ else:
+ self.log().information('Skipping empty token run.')
+
+ GroupWorkspaces(InputWorkspaces=outputs, OutputWorkspace=self.output)
+ self.setProperty('OutputWorkspace', mtd[self.output])
+ if self.reduction_type == 'ReduceWater':
+ self.setProperty('SensitivityOutputWorkspace', mtd[self.output_sens])
+
+ def reduce(self, i):
+
+ [process_transmission_absorber, transmission_absorber_name] = needs_processing(self.atransmission, 'Absorber')
+ self.progress.report('Processing transmission absorber')
+ if process_transmission_absorber:
+ SANSILLReduction(Run=self.atransmission,
+ ProcessAs='Absorber',
+ NormaliseBy=self.normalise,
+ OutputWorkspace=transmission_absorber_name)
+
+ [process_transmission_beam, transmission_beam_name] = needs_processing(self.btransmission, 'Beam')
+ self.progress.report('Processing transmission beam')
+ flux_name = transmission_beam_name + '_Flux'
+ if process_transmission_beam:
+ SANSILLReduction(Run=self.btransmission,
+ ProcessAs='Beam',
+ NormaliseBy=self.normalise,
+ OutputWorkspace=transmission_beam_name,
+ BeamRadius=self.radius,
+ FluxOutputWorkspace=flux_name,
+ AbsorberInputWorkspace=transmission_absorber_name)
+
+ [process_container_transmission, container_transmission_name] = needs_processing(self.ctransmission, 'Transmission')
+ self.progress.report('Processing container transmission')
+ if process_container_transmission:
+ SANSILLReduction(Run=self.ctransmission,
+ ProcessAs='Transmission',
+ OutputWorkspace=container_transmission_name,
+ AbsorberInputWorkspace=transmission_absorber_name,
+ BeamInputWorkspace=transmission_beam_name,
+ NormaliseBy=self.normalise,
+ BeamRadius=self.radius)
+
+ [process_sample_transmission, sample_transmission_name] = needs_processing(self.stransmission, 'Transmission')
+ self.progress.report('Processing sample transmission')
+ if process_sample_transmission:
+ SANSILLReduction(Run=self.stransmission,
+ ProcessAs='Transmission',
+ OutputWorkspace=sample_transmission_name,
+ AbsorberInputWorkspace=transmission_absorber_name,
+ BeamInputWorkspace=transmission_beam_name,
+ NormaliseBy=self.normalise,
+ BeamRadius=self.radius)
+
+ absorber = self.absorber[i] if len(self.absorber) == self.dimensionality else self.absorber[0]
+ [process_absorber, absorber_name] = needs_processing(absorber, 'Absorber')
+ self.progress.report('Processing absorber')
+ if process_absorber:
+ SANSILLReduction(Run=absorber,
+ ProcessAs='Absorber',
+ NormaliseBy=self.normalise,
+ OutputWorkspace=absorber_name)
+
+ beam = self.beam[i] if len(self.beam) == self.dimensionality else self.beam[0]
+ [process_beam, beam_name] = needs_processing(beam, 'Beam')
+ flux_name = beam_name + '_Flux' if not self.flux[0] else ''
+ self.progress.report('Processing beam')
+ if process_beam:
+ SANSILLReduction(Run=beam,
+ ProcessAs='Beam',
+ OutputWorkspace=beam_name,
+ NormaliseBy=self.normalise,
+ BeamRadius=self.radius,
+ AbsorberInputWorkspace=absorber_name,
+ FluxOutputWorkspace=flux_name)
+
+ if self.flux[0]:
+ flux = self.flux[i] if len(self.flux) == self.dimensionality else self.flux[0]
+ [process_flux, flux_name] = needs_processing(flux, 'Flux')
+ self.progress.report('Processing flux')
+ if process_flux:
+ SANSILLReduction(Run=flux,
+ ProcessAs='Beam',
+ OutputWorkspace=flux_name.replace('Flux', 'Beam'),
+ NormaliseBy=self.normalise,
+ BeamRadius=self.radius,
+ AbsorberInputWorkspace=absorber_name,
+ FluxOutputWorkspace=flux_name)
+
+ container = self.container[i] if len(self.container) == self.dimensionality else self.container[0]
+ [process_container, container_name] = needs_processing(container, 'Container')
+ self.progress.report('Processing container')
+ if process_container:
+ SANSILLReduction(Run=container,
+ ProcessAs='Container',
+ OutputWorkspace=container_name,
+ AbsorberInputWorkspace=absorber_name,
+ BeamInputWorkspace=beam_name,
+ CacheSolidAngle=True,
+ TransmissionInputWorkspace=container_transmission_name,
+ NormaliseBy=self.normalise)
+
+ # this is the default mask, the same for all the distance configurations
+ [load_default_mask, default_mask_name] = needs_loading(self.default_mask, 'DefaultMask')
+ self.progress.report('Loading default mask')
+ if load_default_mask:
+ LoadNexusProcessed(Filename=self.default_mask, OutputWorkspace=default_mask_name)
+
+ # this is the beam stop mask, potentially different at each distance configuration
+ mask = self.mask[i] if len(self.mask) == self.dimensionality else self.mask[0]
+ [load_mask, mask_name] = needs_loading(mask, 'Mask')
+ self.progress.report('Loading mask')
+ if load_mask:
+ LoadNexusProcessed(Filename=mask, OutputWorkspace=mask_name)
+
+ sens_input = ''
+ ref_input = ''
+ flux_input = ''
+ if not self.reference[0]:
+ flux_input = flux_name
+ if self.sensitivity:
+ sens = self.sensitivity[i] if len(self.sensitivity) == self.dimensionality else self.sensitivity[0]
+ [load_sensitivity, sensitivity_name] = needs_loading(sens, 'Sensitivity')
+ sens_input = sensitivity_name
+ self.progress.report('Loading sensitivity')
+ if load_sensitivity:
+ LoadNexusProcessed(Filename=sens, OutputWorkspace=sensitivity_name)
+ else:
+ reference = self.reference[i] if len(self.reference) == self.dimensionality else self.reference[0]
+ [load_reference, reference_name] = needs_loading(reference, 'Reference')
+ ref_input = reference_name
+ self.progress.report('Loading reference')
+ if load_reference:
+ LoadNexusProcessed(Filename=reference, OutputWorkspace=reference_name)
+
+ output = self.output + '_' + str(i + 1)
+ [_, sample_name] = needs_processing(self.sample[i], 'Sample')
+ self.progress.report('Processing sample at detector configuration '+str(i+1))
+ if self.reduction_type == 'ReduceSample':
+ SANSILLReduction(Run=self.sample[i],
+ ProcessAs='Sample',
+ OutputWorkspace=sample_name,
+ ReferenceInputWorkspace=ref_input,
+ AbsorberInputWorkspace=absorber_name,
+ BeamInputWorkspace=beam_name,
+ CacheSolidAngle=True,
+ ContainerInputWorkspace=container_name,
+ TransmissionInputWorkspace=sample_transmission_name,
+ MaskedInputWorkspace=mask_name,
+ DefaultMaskedInputWorkspace=default_mask_name,
+ SensitivityInputWorkspace=sens_input,
+ FluxInputWorkspace=flux_input,
+ NormaliseBy=self.normalise,
+ SampleThickness=self.getProperty('SampleThickness').value,
+ WaterCrossSection=self.getProperty('WaterCrossSection').value)
+ SANSILLIntegration(InputWorkspace=sample_name,
+ OutputWorkspace=output,
+ OutputType=self.getPropertyValue('OutputType'),
+ CalculateResolution=self.getPropertyValue('CalculateResolution'),
+ DefaultQBinning=self.getPropertyValue('DefaultQBinning'),
+ BinningFactor=self.getProperty('BinningFactor').value,
+ OutputBinning=self.getPropertyValue('OutputBinning'),
+ NPixelDivision=self.getProperty('NPixelDivision').value,
+ NumberOfWedges=self.getProperty('NumberOfWedges').value,
+ WedgeAngle=self.getProperty('WedgeAngle').value,
+ WedgeOffset=self.getProperty('WedgeOffset').value,
+ AsymmetricWedges=self.getProperty('AsymmetricWedges').value)
+ elif self.reduction_type == 'ReduceWater':
+ SANSILLReduction(Run=self.sample[i],
+ ProcessAs='Reference',
+ OutputWorkspace=output,
+ AbsorberInputWorkspace=absorber_name,
+ BeamInputWorkspace=beam_name,
+ CacheSolidAngle=True,
+ ContainerInputWorkspace=container_name,
+ NormaliseBy=self.normalise,
+ TransmissionInputWorkspace=sample_transmission_name,
+ SensitivityOutputWorkspace=self.output_sens,
+ MaskedInputWorkspace=mask_name,
+ DefaultMaskedInputWorkspace=default_mask_name,
+ SampleThickness=self.getProperty('SampleThickness').value)
+
+AlgorithmFactory.subscribe(SANSILLAutoProcess)
diff --git a/Framework/PythonInterface/plugins/algorithms/WorkflowAlgorithms/SANSILLIntegration.py b/Framework/PythonInterface/plugins/algorithms/WorkflowAlgorithms/SANSILLIntegration.py
index 170825a74f9ba7b8760f8bccc614c85c6608d5bb..29de77aaec46311b8d99392f48c46c74246cab25 100644
--- a/Framework/PythonInterface/plugins/algorithms/WorkflowAlgorithms/SANSILLIntegration.py
+++ b/Framework/PythonInterface/plugins/algorithms/WorkflowAlgorithms/SANSILLIntegration.py
@@ -283,9 +283,11 @@ class SANSILLIntegration(PythonAlgorithm):
else:
self._deltaQ = MonochromaticScalarQCartesian(wavelength, delta_wavelength, x1, y1, x2, y2, x3, y3, l1, l2)
else:
- pos1 = source_aperture.find('(') + 1
- pos3 = source_aperture.find(')')
- r1 = float(source_aperture[pos1:pos3]) * to_meter
+ if '(' in source_aperture:
+ pos1 = source_aperture.find('(') + 1
+ pos3 = source_aperture.find(')')
+ source_aperture = source_aperture[pos1:pos3]
+ r1 = float(source_aperture) * to_meter
r2 = run.getLogData('Beam.sample_ap_x_or_diam').value * to_meter
if is_tof:
raise RuntimeError('TOF resolution is not supported yet')
diff --git a/Framework/PythonInterface/plugins/algorithms/WorkflowAlgorithms/SANSILLReduction.py b/Framework/PythonInterface/plugins/algorithms/WorkflowAlgorithms/SANSILLReduction.py
index 02b0d8f0980de50dec0ab5a06ee728cc9799f613..01773721d0300e4d844063d6b46e70b51334706c 100644
--- a/Framework/PythonInterface/plugins/algorithms/WorkflowAlgorithms/SANSILLReduction.py
+++ b/Framework/PythonInterface/plugins/algorithms/WorkflowAlgorithms/SANSILLReduction.py
@@ -6,7 +6,7 @@
# SPDX - License - Identifier: GPL - 3.0 +
from __future__ import (absolute_import, division, print_function)
-from mantid.api import PythonAlgorithm, MatrixWorkspaceProperty, MultipleFileProperty, PropertyMode, Progress
+from mantid.api import PythonAlgorithm, MatrixWorkspaceProperty, MultipleFileProperty, PropertyMode, Progress, WorkspaceGroup
from mantid.kernel import Direction, EnabledWhenProperty, FloatBoundedValidator, LogicOperator, PropertyCriterion, StringListValidator
from mantid.simpleapi import *
from math import fabs
@@ -37,18 +37,31 @@ class SANSILLReduction(PythonAlgorithm):
issues['BeamInputWorkspace'] = 'Beam input workspace is mandatory for transmission calculation.'
return issues
+ @staticmethod
+ def _get_solid_angle_method(instrument):
+ if instrument in ['D11', 'D11lr']:
+ return 'Rectangle'
+ else:
+ return 'GenericShape'
+
+ @staticmethod
+ def _make_solid_angle_name(ws):
+ return mtd[ws].getInstrument().getName()+'_'+str(int(mtd[ws].getRun().getLogData('L2').value))+'m_SolidAngle'
+
@staticmethod
def _check_distances_match(ws1, ws2):
"""
Checks if the detector distance between two workspaces are close enough
@param ws1 : workspace 1
@param ws2 : workspace 2
- @return true if the detector distance difference is less than 1 cm
"""
tolerance = 0.01 #m
l2_1 = ws1.getRun().getLogData('L2').value
l2_2 = ws2.getRun().getLogData('L2').value
- return fabs(l2_1 - l2_2) < tolerance
+ r1 = ws1.getRunNumber()
+ r2 = ws2.getRunNumber()
+ if fabs(l2_1 - l2_2) > tolerance:
+ logger.warning('Different distances detected! {0}: {1}, {2}: {3}'.format(r1, l2_1, r2, l2_2))
@staticmethod
def _check_processed_flag(ws, value):
@@ -64,6 +77,11 @@ class SANSILLReduction(PythonAlgorithm):
return '<infinite-cylinder id="flux"><centre x="0.0" y="0.0" z="0.0"/><axis x="0.0" y="0.0" z="1.0"/>' \
'<radius val="{0}"/></infinite-cylinder>'.format(radius)
+ @staticmethod
+ def _mask(ws, masked_ws):
+ if masked_ws.detectorInfo().hasMaskedDetectors():
+ MaskDetectors(Workspace=ws, MaskedWorkspace=masked_ws)
+
def PyInit(self):
self.declareProperty(MultipleFileProperty('Run', extensions=['nxs']),
@@ -100,7 +118,7 @@ class SANSILLReduction(PythonAlgorithm):
doc='Choose the normalisation type.')
self.declareProperty('BeamRadius', 0.05, validator=FloatBoundedValidator(lower=0.),
- doc='Beam raduis [m]; used for beam center finding and transmission calculations.')
+ doc='Beam raduis [m]; used for beam center finding, transmission and flux calculations.')
self.setPropertySettings('BeamRadius',
EnabledWhenProperty(beam, transmission, LogicOperator.Or))
@@ -193,17 +211,27 @@ class SANSILLReduction(PythonAlgorithm):
self.setPropertySettings('FluxOutputWorkspace', beam)
+ self.declareProperty('CacheSolidAngle', False, doc='Whether or not to cache the solid angle workspace.')
+
+ self.declareProperty('WaterCrossSection', 1., doc='Provide water cross-section; '
+ 'used only if the absolute scale is done by dividing to water.')
+
+ self.declareProperty(MatrixWorkspaceProperty('DefaultMaskedInputWorkspace', '',
+ direction=Direction.Input,
+ optional=PropertyMode.Optional),
+ doc='Workspace to copy the mask from; for example, the bad detector edges.')
+
+ self.setPropertySettings('DefaultMaskedInputWorkspace', EnabledWhenProperty(sample, reference, LogicOperator.Or))
+
def _normalise(self, ws):
"""
Normalizes the workspace by time (SampleLog Timer) or Monitor (ID=100000)
@param ws : the input workspace
"""
normalise_by = self.getPropertyValue('NormaliseBy')
+ monID = 100000 if self._instrument != 'D33' else 500000
if normalise_by == 'Monitor':
mon = ws + '_mon'
- monID = 100000
- if mtd[ws].getInstrument().getName() == 'D33':
- monID = 500000
ExtractSpectra(InputWorkspace=ws, DetectorList=monID, OutputWorkspace=mon)
if mtd[mon].readY(0)[0] == 0:
raise RuntimeError('Normalise to monitor requested, but monitor has 0 counts.')
@@ -220,6 +248,9 @@ class SANSILLReduction(PythonAlgorithm):
raise RuntimeError('Unable to normalise to time; duration found is 0 seconds.')
else:
raise RuntimeError('Normalise to timer requested, but timer information is not available.')
+ # regardless on normalisation, mask out the monitors, but do not extract them, since extracting is slow
+ # masking however is needed to get more reasonable scales in the instrument view
+ MaskDetectors(Workspace=ws, DetectorList=[monID, monID+1])
def _process_beam(self, ws):
"""
@@ -275,8 +306,7 @@ class SANSILLReduction(PythonAlgorithm):
@param ws: input workspace name
@param beam_ws: empty beam workspace
"""
- if not self._check_distances_match(mtd[ws], beam_ws):
- self.log().warning('Different detector distances found for empty beam and transmission runs!')
+ self._check_distances_match(mtd[ws], beam_ws)
RebinToWorkspace(WorkspaceToRebin=ws, WorkspaceToMatch=beam_ws, OutputWorkspace=ws)
radius = self.getProperty('BeamRadius').value
shapeXML = self._cylinder(radius)
@@ -312,28 +342,29 @@ class SANSILLReduction(PythonAlgorithm):
if reference_ws:
if not self._check_processed_flag(reference_ws, 'Reference'):
self.log().warning('Reference input workspace is not processed as reference.')
- Divide(LHSWorkspace=ws, RHSWorkspace=reference_ws, OutputWorkspace=ws)
+ Divide(LHSWorkspace=ws, RHSWorkspace=reference_ws, OutputWorkspace=ws, WarnOnZeroDivide=False)
+ Scale(InputWorkspace=ws, Factor=self.getProperty('WaterCrossSection').value, OutputWorkspace=ws)
+ self._mask(ws, reference_ws)
coll_ws = reference_ws
else:
sensitivity_in = self.getProperty('SensitivityInputWorkspace').value
if sensitivity_in:
if not self._check_processed_flag(sensitivity_in, 'Sensitivity'):
self.log().warning('Sensitivity input workspace is not processed as sensitivity.')
- Divide(LHSWorkspace=ws, RHSWorkspace=sensitivity_in, OutputWorkspace=ws)
+ Divide(LHSWorkspace=ws, RHSWorkspace=sensitivity_in, OutputWorkspace=ws, WarnOnZeroDivide=False)
+ self._mask(ws, sensitivity_in)
flux_in = self.getProperty('FluxInputWorkspace').value
if flux_in:
coll_ws = flux_in
flux_ws = ws + '_flux'
if self._mode == 'TOF':
RebinToWorkspace(WorkspaceToRebin=flux_in, WorkspaceToMatch=ws, OutputWorkspace=flux_ws)
- Divide(LHSWorkspace=ws, RHSWorkspace=flux_ws, OutputWorkspace=ws)
+ Divide(LHSWorkspace=ws, RHSWorkspace=flux_ws, OutputWorkspace=ws, WarnOnZeroDivide=False)
DeleteWorkspace(flux_ws)
else:
- Divide(LHSWorkspace=ws, RHSWorkspace=flux_in, OutputWorkspace=ws)
+ Divide(LHSWorkspace=ws, RHSWorkspace=flux_in, OutputWorkspace=ws, WarnOnZeroDivide=False)
if coll_ws:
- if not self._check_distances_match(mtd[ws], coll_ws):
- self.log().warning(
- 'Different detector distances found for the reference/flux and sample runs!')
+ self._check_distances_match(mtd[ws], coll_ws)
sample_coll = mtd[ws].getRun().getLogData('collimation.actual_position').value
ref_coll = coll_ws.getRun().getLogData('collimation.actual_position').value
flux_factor = (sample_coll ** 2) / (ref_coll ** 2)
@@ -366,8 +397,7 @@ class SANSILLReduction(PythonAlgorithm):
AddSampleLog(Workspace=ws, LogName='BeamCenterX', LogText=str(beam_x), LogType='Number')
AddSampleLog(Workspace=ws, LogName='BeamCenterY', LogText=str(beam_y), LogType='Number')
MoveInstrumentComponent(Workspace=ws, X=-beam_x, Y=-beam_y, ComponentName='detector')
- if not self._check_distances_match(mtd[ws], beam_ws):
- self.log().warning('Different detector distances found for empty beam and sample runs!')
+ self._check_distances_match(mtd[ws], beam_ws)
def _apply_transmission(self, ws, transmission_ws):
"""
@@ -400,24 +430,14 @@ class SANSILLReduction(PythonAlgorithm):
"""
if not self._check_processed_flag(container_ws, 'Container'):
self.log().warning('Container input workspace is not processed as container.')
- if not self._check_distances_match(mtd[ws], container_ws):
- self.log().warning(
- 'Different detector distances found for container and sample runs!')
+ self._check_distances_match(mtd[ws], container_ws)
Minus(LHSWorkspace=ws, RHSWorkspace=container_ws, OutputWorkspace=ws)
- def _apply_mask(self, ws, mask_ws):
+ def _apply_parallax(self, ws):
"""
- Applies the mask
- @param ws: input workspace
- @param mask_ws: input masked workspace
+ Applies the parallax correction
+ @param ws : the input workspace
"""
- masked_ws = ws + '_mask'
- CloneWorkspace(InputWorkspace=mask_ws, OutputWorkspace=masked_ws)
- ExtractMonitors(InputWorkspace=masked_ws, DetectorWorkspace=masked_ws)
- MaskDetectors(Workspace=ws, MaskedWorkspace=masked_ws)
- DeleteWorkspace(masked_ws)
-
- def _apply_parallax(self, ws):
self.log().information('Performing parallax correction')
if self._instrument == 'D33':
components = ['back_detector', 'front_detector_top', 'front_detector_bottom',
@@ -444,14 +464,40 @@ class SANSILLReduction(PythonAlgorithm):
else:
self.log().information('No tau available in IPF, skipping dead time correction.')
+ def _finalize(self, ws, process):
+ if process != 'Transmission':
+ if self._instrument == 'D33':
+ CalculateDynamicRange(Workspace=ws, ComponentNames=['back_detector', 'front_detector'])
+ else:
+ CalculateDynamicRange(Workspace=ws)
+ mtd[ws].getRun().addProperty('ProcessedAs', process, True)
+ RenameWorkspace(InputWorkspace=ws, OutputWorkspace=ws[2:])
+ self.setProperty('OutputWorkspace', mtd[ws[2:]])
+
+ def _apply_masks(self, ws):
+ # apply the default mask, e.g. the bad detector edges
+ default_mask_ws = self.getProperty('DefaultMaskedInputWorkspace').value
+ if default_mask_ws:
+ self._mask(ws, default_mask_ws)
+ # apply the beam stop mask
+ mask_ws = self.getProperty('MaskedInputWorkspace').value
+ if mask_ws:
+ self._mask(ws, mask_ws)
+
def PyExec(self):
process = self.getPropertyValue('ProcessAs')
processes = ['Absorber', 'Beam', 'Transmission', 'Container', 'Reference', 'Sample']
progress = Progress(self, start=0.0, end=1.0, nreports=processes.index(process) + 1)
ws = '__' + self.getPropertyValue('OutputWorkspace')
- LoadAndMerge(Filename=self.getPropertyValue('Run').replace(',','+'), LoaderName='LoadILLSANS', OutputWorkspace=ws)
+ # we do not want the summing done by LoadAndMerge since it will be pair-wise and slow
+ # instead we load and list, and merge once with merge runs
+ LoadAndMerge(Filename=self.getPropertyValue('Run').replace('+',','), LoaderName='LoadILLSANS', OutputWorkspace=ws)
+ if isinstance(mtd[ws], WorkspaceGroup):
+ tmp = '__tmp'+ws
+ MergeRuns(InputWorkspaces=ws, OutputWorkspace=tmp)
+ DeleteWorkspaces(ws)
+ RenameWorkspace(InputWorkspace=tmp, OutputWorkspace=ws)
self._normalise(ws)
- ExtractMonitors(InputWorkspace=ws, DetectorWorkspace=ws)
self._instrument = mtd[ws].getInstrument().getName()
run = mtd[ws].getRun()
if run.hasProperty('tof_mode'):
@@ -476,18 +522,23 @@ class SANSILLReduction(PythonAlgorithm):
transmission_ws = self.getProperty('TransmissionInputWorkspace').value
if transmission_ws:
self._apply_transmission(ws, transmission_ws)
- solid_angle = ws + '_sa'
- SolidAngle(InputWorkspace=ws, OutputWorkspace=solid_angle)
- Divide(LHSWorkspace=ws, RHSWorkspace=solid_angle, OutputWorkspace=ws)
- DeleteWorkspace(solid_angle)
+ solid_angle = self._make_solid_angle_name(ws)
+ cache = self.getProperty('CacheSolidAngle').value
+ if cache:
+ if not mtd.doesExist(solid_angle):
+ SolidAngle(InputWorkspace=ws, OutputWorkspace=solid_angle,
+ Method=self._get_solid_angle_method(self._instrument))
+ else:
+ SolidAngle(InputWorkspace=ws, OutputWorkspace=solid_angle)
+ Divide(LHSWorkspace=ws, RHSWorkspace=solid_angle, OutputWorkspace=ws, WarnOnZeroDivide=False)
+ if not cache:
+ DeleteWorkspace(solid_angle)
progress.report()
if process in ['Reference', 'Sample']:
container_ws = self.getProperty('ContainerInputWorkspace').value
if container_ws:
self._apply_container(ws, container_ws)
- mask_ws = self.getProperty('MaskedInputWorkspace').value
- if mask_ws:
- self._apply_mask(ws, mask_ws)
+ self._apply_masks(ws)
thickness = self.getProperty('SampleThickness').value
NormaliseByThickness(InputWorkspace=ws, OutputWorkspace=ws, SampleThickness=thickness)
# parallax (gondola) effect
@@ -501,14 +552,7 @@ class SANSILLReduction(PythonAlgorithm):
elif process == 'Sample':
self._process_sample(ws)
progress.report()
- if process != 'Transmission':
- if self._instrument == 'D33':
- CalculateDynamicRange(Workspace=ws, ComponentNames=['back_detector', 'front_detector'])
- else:
- CalculateDynamicRange(Workspace=ws)
- mtd[ws].getRun().addProperty('ProcessedAs', process, True)
- RenameWorkspace(InputWorkspace=ws, OutputWorkspace=ws[2:])
- self.setProperty('OutputWorkspace', mtd[ws[2:]])
+ self._finalize(ws, process)
# Register algorithm with Mantid
AlgorithmFactory.subscribe(SANSILLReduction)
diff --git a/Framework/PythonInterface/test/python/plugins/algorithms/WorkflowAlgorithms/SANSILLReductionTest.py b/Framework/PythonInterface/test/python/plugins/algorithms/WorkflowAlgorithms/SANSILLReductionTest.py
index a27ce13af21656b4897a746007b87d47d38e94dc..e780119ca950e82d66cb82d824a69707f6a5fe93 100644
--- a/Framework/PythonInterface/test/python/plugins/algorithms/WorkflowAlgorithms/SANSILLReductionTest.py
+++ b/Framework/PythonInterface/test/python/plugins/algorithms/WorkflowAlgorithms/SANSILLReductionTest.py
@@ -36,17 +36,17 @@ class SANSILLReductionTest(unittest.TestCase):
def test_absorber(self):
SANSILLReduction(Run='010462', ProcessAs='Absorber', OutputWorkspace='Cd')
- self._check_output(mtd['Cd'], True, 1, 128*128)
+ self._check_output(mtd['Cd'], True, 1, 128*128+2)
self._check_process_flag(mtd['Cd'], 'Absorber')
def test_beam(self):
SANSILLReduction(Run='010414', ProcessAs='Beam', OutputWorkspace='Db', FluxOutputWorkspace='Fl')
- self._check_output(mtd['Db'], True, 1, 128*128)
+ self._check_output(mtd['Db'], True, 1, 128*128+2)
self._check_process_flag(mtd['Db'], 'Beam')
run = mtd['Db'].getRun()
- self.assertAlmostEqual(run.getLogData('BeamCenterX').value, -0.0048, delta=1e-4)
+ self.assertAlmostEqual(run.getLogData('BeamCenterX').value, 0.0048, delta=1e-4)
self.assertAlmostEqual(run.getLogData('BeamCenterY').value, -0.0027, delta=1e-4)
- self._check_output(mtd['Fl'], False, 1, 128*128)
+ self._check_output(mtd['Fl'], False, 1, 128*128+2)
self._check_process_flag(mtd['Fl'], 'Beam')
self.assertAlmostEqual(mtd['Fl'].readY(0)[0], 6628249, delta=1)
self.assertAlmostEqual(mtd['Fl'].readE(0)[0], 8566, delta=1)
@@ -54,62 +54,62 @@ class SANSILLReductionTest(unittest.TestCase):
def test_transmission(self):
SANSILLReduction(Run='010414', ProcessAs='Beam', OutputWorkspace='Db')
SANSILLReduction(Run='010585', ProcessAs='Transmission', BeamInputWorkspace='Db', OutputWorkspace='Tr')
- self.assertAlmostEqual(mtd['Tr'].readY(0)[0], 0.640, delta=1e-3)
+ self.assertAlmostEqual(mtd['Tr'].readY(0)[0], 0.642, delta=1e-3)
self.assertAlmostEqual(mtd['Tr'].readE(0)[0], 0.0019, delta=1e-4)
self._check_process_flag(mtd['Tr'], 'Transmission')
def test_container(self):
SANSILLReduction(Run='010460', ProcessAs='Container', OutputWorkspace='can')
- self._check_output(mtd['can'], True, 1, 128*128)
+ self._check_output(mtd['can'], True, 1, 128*128+2)
self._check_process_flag(mtd['can'], 'Container')
def test_reference(self):
SANSILLReduction(Run='010453', ProcessAs='Reference', SensitivityOutputWorkspace='sens', OutputWorkspace='water')
- self._check_output(mtd['water'], True, 1, 128*128)
- self._check_output(mtd['sens'], False, 1, 128*128)
+ self._check_output(mtd['water'], True, 1, 128*128+2)
+ self._check_output(mtd['sens'], False, 1, 128*128+2)
self._check_process_flag(mtd['water'], 'Reference')
self._check_process_flag(mtd['sens'], 'Sensitivity')
def test_sample(self):
SANSILLReduction(Run='010569', ProcessAs='Sample', OutputWorkspace='sample')
- self._check_output(mtd['sample'], True, 1, 128*128)
+ self._check_output(mtd['sample'], True, 1, 128*128+2)
self._check_process_flag(mtd['sample'], 'Sample')
def test_absorber_tof(self):
# D33 VTOF
# actually this is a container run, not an absorber, but is fine for this test
SANSILLReduction(Run='093409', ProcessAs='Absorber', OutputWorkspace='absorber')
- self._check_output(mtd['absorber'], True, 30, 256*256)
+ self._check_output(mtd['absorber'], True, 30, 256*256+2)
self._check_process_flag(mtd['absorber'], 'Absorber')
def test_beam_tof(self):
# D33 VTOF
SANSILLReduction(Run='093406', ProcessAs='Beam', OutputWorkspace='beam', FluxOutputWorkspace='flux')
- self._check_output(mtd['beam'], True, 30, 256*256)
+ self._check_output(mtd['beam'], True, 30, 256*256+2)
self._check_process_flag(mtd['beam'], 'Beam')
run = mtd['beam'].getRun()
self.assertAlmostEqual(run.getLogData('BeamCenterX').value, -0.0025, delta=1e-4)
self.assertAlmostEqual(run.getLogData('BeamCenterY').value, 0.0009, delta=1e-4)
- self._check_output(mtd['flux'], False, 30, 256*256)
+ self._check_output(mtd['flux'], False, 30, 256*256+2)
self._check_process_flag(mtd['flux'], 'Beam')
def test_transmission_tof(self):
# D33 VTOF
SANSILLReduction(Run='093406', ProcessAs='Beam', OutputWorkspace='beam')
SANSILLReduction(Run='093407', ProcessAs='Transmission', BeamInputWorkspace='beam', OutputWorkspace='ctr')
- self._check_output(mtd['ctr'], False, 75, 1)
+ self._check_output(mtd['ctr'], False, 97, 1)
def test_reference_tof(self):
# D33 VTOF
# this is actually a sample run, not water, but is fine for this test
SANSILLReduction(Run='093410', ProcessAs='Reference', OutputWorkspace='ref')
- self._check_output(mtd['ref'], True, 30, 256*256)
+ self._check_output(mtd['ref'], True, 30, 256*256+2)
self._check_process_flag(mtd['ref'], 'Reference')
def test_sample_tof(self):
# D33 VTOF, Pluronic F127
SANSILLReduction(Run='093410', ProcessAs='Sample', OutputWorkspace='sample')
- self._check_output(mtd['sample'], True, 30, 256*256)
+ self._check_output(mtd['sample'], True, 30, 256*256+2)
self._check_process_flag(mtd['sample'], 'Sample')
def _check_process_flag(self, ws, value):
diff --git a/Testing/Data/DocTest/ILL/D11/002866.nxs.md5 b/Testing/Data/DocTest/ILL/D11/002866.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..36728eeb8138e38a3e499f126e13f0cccce68574
--- /dev/null
+++ b/Testing/Data/DocTest/ILL/D11/002866.nxs.md5
@@ -0,0 +1 @@
+ea0980e2c34784d06f23506358d48162
diff --git a/Testing/Data/DocTest/ILL/D11/002867.nxs.md5 b/Testing/Data/DocTest/ILL/D11/002867.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..ec41a57079c9634955eef73b442c6d183eb41713
--- /dev/null
+++ b/Testing/Data/DocTest/ILL/D11/002867.nxs.md5
@@ -0,0 +1 @@
+70372eb2b5dd013159b4d236a3fe96f9
diff --git a/Testing/Data/DocTest/ILL/D11/002868.nxs.md5 b/Testing/Data/DocTest/ILL/D11/002868.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..3bdcc9a30eb1ea8842c4e2200c735fadc033769d
--- /dev/null
+++ b/Testing/Data/DocTest/ILL/D11/002868.nxs.md5
@@ -0,0 +1 @@
+0c6f6b328d6c24219ffc312b98e52595
diff --git a/Testing/Data/DocTest/ILL/D11/002869.nxs.md5 b/Testing/Data/DocTest/ILL/D11/002869.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..dd350d2ea7d355ed8ccf1f78956344549b948ef5
--- /dev/null
+++ b/Testing/Data/DocTest/ILL/D11/002869.nxs.md5
@@ -0,0 +1 @@
+8c988d99461a7f36de37dfe2d6b5973c
diff --git a/Testing/Data/DocTest/ILL/D11/002870.nxs.md5 b/Testing/Data/DocTest/ILL/D11/002870.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..23c0142df9002895e316c47ae2199dace6dee29f
--- /dev/null
+++ b/Testing/Data/DocTest/ILL/D11/002870.nxs.md5
@@ -0,0 +1 @@
+81b06aae8be76a1d76c943456e78e989
diff --git a/Testing/Data/DocTest/ILL/D11/002871.nxs.md5 b/Testing/Data/DocTest/ILL/D11/002871.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..34e4cac3aac7d7414d17cb5a55f5a28e6e460f64
--- /dev/null
+++ b/Testing/Data/DocTest/ILL/D11/002871.nxs.md5
@@ -0,0 +1 @@
+4816c2d31b75a552d903885e01498385
diff --git a/Testing/Data/DocTest/ILL/D11/002878.nxs.md5 b/Testing/Data/DocTest/ILL/D11/002878.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..9f3bbcfed330b023495229c58dc236c1041e073c
--- /dev/null
+++ b/Testing/Data/DocTest/ILL/D11/002878.nxs.md5
@@ -0,0 +1 @@
+57be2fd2dd38dc99a0e5f64d4d0519e3
diff --git a/Testing/Data/DocTest/ILL/D11/002879.nxs.md5 b/Testing/Data/DocTest/ILL/D11/002879.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..04c26db748a83e1536d544ed0a8711bb09f69319
--- /dev/null
+++ b/Testing/Data/DocTest/ILL/D11/002879.nxs.md5
@@ -0,0 +1 @@
+ee48c20d4ae3129ef42a8d8fd305a43c
diff --git a/Testing/Data/DocTest/ILL/D11/002880.nxs.md5 b/Testing/Data/DocTest/ILL/D11/002880.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..fccd296bdee6a3b1fe08407d180bd18f4f2a44c8
--- /dev/null
+++ b/Testing/Data/DocTest/ILL/D11/002880.nxs.md5
@@ -0,0 +1 @@
+d9df0abe4211e0ab2d6a663bc4110089
diff --git a/Testing/Data/DocTest/ILL/D11/002881.nxs.md5 b/Testing/Data/DocTest/ILL/D11/002881.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..ddc3bebf2854957a894e905e8211e5bcea31705f
--- /dev/null
+++ b/Testing/Data/DocTest/ILL/D11/002881.nxs.md5
@@ -0,0 +1 @@
+6fc09449a006f6fbf9b844077bd24e35
diff --git a/Testing/Data/DocTest/ILL/D11/002883.nxs.md5 b/Testing/Data/DocTest/ILL/D11/002883.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..d07bd34c48682332939e1f74238ea4f776a0eba5
--- /dev/null
+++ b/Testing/Data/DocTest/ILL/D11/002883.nxs.md5
@@ -0,0 +1 @@
+96da95f0de38b148f032f68c0336ef62
diff --git a/Testing/Data/DocTest/ILL/D11/002884.nxs.md5 b/Testing/Data/DocTest/ILL/D11/002884.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..f6acc0b48706c1a94a819564de479b8dd55360f4
--- /dev/null
+++ b/Testing/Data/DocTest/ILL/D11/002884.nxs.md5
@@ -0,0 +1 @@
+4bac48284459100fb122328f240ca84f
diff --git a/Testing/Data/DocTest/ILL/D11/002885.nxs.md5 b/Testing/Data/DocTest/ILL/D11/002885.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..42f7d7582e4b6bdce9d90c17ec69475b76a06b26
--- /dev/null
+++ b/Testing/Data/DocTest/ILL/D11/002885.nxs.md5
@@ -0,0 +1 @@
+06dbd4beede52c8504bc8b95eb7f0dca
diff --git a/Testing/Data/DocTest/ILL/D11/002887.nxs.md5 b/Testing/Data/DocTest/ILL/D11/002887.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..0ae40d1692162ad0297b6c920efd44fa908111fd
--- /dev/null
+++ b/Testing/Data/DocTest/ILL/D11/002887.nxs.md5
@@ -0,0 +1 @@
+4c0820b0e1f2b1de761d0b2f914cfa98
diff --git a/Testing/Data/DocTest/ILL/D11/002888.nxs.md5 b/Testing/Data/DocTest/ILL/D11/002888.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..5d34e6f5a2321bd649cc43ec14a49bf6cf568e3e
--- /dev/null
+++ b/Testing/Data/DocTest/ILL/D11/002888.nxs.md5
@@ -0,0 +1 @@
+0b19befd46943b9d68b29f9681c360ad
diff --git a/Testing/Data/DocTest/ILL/D11/002889.nxs.md5 b/Testing/Data/DocTest/ILL/D11/002889.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..98799d8d13a4e85248872b7681cda04a265f4bb1
--- /dev/null
+++ b/Testing/Data/DocTest/ILL/D11/002889.nxs.md5
@@ -0,0 +1 @@
+c7100ee0208167bc7c10e4d9ab015d36
diff --git a/Testing/Data/DocTest/ILL/D11/002949.nxs.md5 b/Testing/Data/DocTest/ILL/D11/002949.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..236cf416f94bc34b8d194361bd7ac7f08c93fc72
--- /dev/null
+++ b/Testing/Data/DocTest/ILL/D11/002949.nxs.md5
@@ -0,0 +1 @@
+9689ff35560d3277fcc87386bd37b760
diff --git a/Testing/Data/DocTest/ILL/D11/002954.nxs.md5 b/Testing/Data/DocTest/ILL/D11/002954.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..d0c0cb011dda635134e81748515394749f94dea9
--- /dev/null
+++ b/Testing/Data/DocTest/ILL/D11/002954.nxs.md5
@@ -0,0 +1 @@
+9f14dcd99b0c5c7ae4b7effc6f2b3a2f
diff --git a/Testing/Data/DocTest/ILL/D11/002960.nxs.md5 b/Testing/Data/DocTest/ILL/D11/002960.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..4185b53d09aa7e4f511e65768a89a3bd1168fe59
--- /dev/null
+++ b/Testing/Data/DocTest/ILL/D11/002960.nxs.md5
@@ -0,0 +1 @@
+149c701e402554f666ef1b243e0cd7e2
diff --git a/Testing/Data/DocTest/ILL/D11/002971.nxs.md5 b/Testing/Data/DocTest/ILL/D11/002971.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..de7230e199d23b2878ee675869abda9420405bb9
--- /dev/null
+++ b/Testing/Data/DocTest/ILL/D11/002971.nxs.md5
@@ -0,0 +1 @@
+b8a1fecf78285426989303488d4d1bb8
diff --git a/Testing/Data/DocTest/ILL/D11/003167.nxs.md5 b/Testing/Data/DocTest/ILL/D11/003167.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..4e9fd11faa58b20f6725c9cedb6c2d97a60fc40e
--- /dev/null
+++ b/Testing/Data/DocTest/ILL/D11/003167.nxs.md5
@@ -0,0 +1 @@
+9bb3a7d7630cf015431fa2d7ecbdba08
diff --git a/Testing/Data/DocTest/ILL/D11/003172.nxs.md5 b/Testing/Data/DocTest/ILL/D11/003172.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..b0f0302d5f580839e860d7f6a86f60e841792943
--- /dev/null
+++ b/Testing/Data/DocTest/ILL/D11/003172.nxs.md5
@@ -0,0 +1 @@
+06f3e3fd8394a682aeb8b1be51c998cb
diff --git a/Testing/Data/DocTest/ILL/D11/003177.nxs.md5 b/Testing/Data/DocTest/ILL/D11/003177.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..77d0ff6339f989797485709a08e0b1600488abac
--- /dev/null
+++ b/Testing/Data/DocTest/ILL/D11/003177.nxs.md5
@@ -0,0 +1 @@
+979dcc91a0a0cf543e0ea7ee9ddea52d
diff --git a/Testing/Data/DocTest/ILL/D11/003187.nxs.md5 b/Testing/Data/DocTest/ILL/D11/003187.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..6c787b0e71d32419d47251130dc408e83ee78cb1
--- /dev/null
+++ b/Testing/Data/DocTest/ILL/D11/003187.nxs.md5
@@ -0,0 +1 @@
+839daf35d5f82e7131d296d8d4d71cc9
diff --git a/Testing/Data/DocTest/ILL/D11/mask1.nxs.md5 b/Testing/Data/DocTest/ILL/D11/mask1.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..d5173eaf008d3431b22418b67bee1312e0bc0afa
--- /dev/null
+++ b/Testing/Data/DocTest/ILL/D11/mask1.nxs.md5
@@ -0,0 +1 @@
+0df395d5e81fd49e470342a1e8dd18c1
diff --git a/Testing/Data/DocTest/ILL/D11/mask2.nxs.md5 b/Testing/Data/DocTest/ILL/D11/mask2.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..9f79a5c4a214fbc5b95bd7b726724214870ab389
--- /dev/null
+++ b/Testing/Data/DocTest/ILL/D11/mask2.nxs.md5
@@ -0,0 +1 @@
+66c16fe62d3a1282956c5c438f28d557
diff --git a/Testing/Data/DocTest/ILL/D11/mask3.nxs.md5 b/Testing/Data/DocTest/ILL/D11/mask3.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..6a5a533f76f793e15480a2274581ff5b8c32a56f
--- /dev/null
+++ b/Testing/Data/DocTest/ILL/D11/mask3.nxs.md5
@@ -0,0 +1 @@
+b3f5134ace660b3ff88361927fd08480
diff --git a/Testing/Data/DocTest/ILL/D11/sens-lamp.nxs.md5 b/Testing/Data/DocTest/ILL/D11/sens-lamp.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..fc0d40ef75aadaee5072272875b8658900db0296
--- /dev/null
+++ b/Testing/Data/DocTest/ILL/D11/sens-lamp.nxs.md5
@@ -0,0 +1 @@
+e830eedaa1fbfb93dd90579d0f98dd1e
diff --git a/Testing/Data/SystemTest/ILL/D11/002866.nxs.md5 b/Testing/Data/SystemTest/ILL/D11/002866.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..36728eeb8138e38a3e499f126e13f0cccce68574
--- /dev/null
+++ b/Testing/Data/SystemTest/ILL/D11/002866.nxs.md5
@@ -0,0 +1 @@
+ea0980e2c34784d06f23506358d48162
diff --git a/Testing/Data/SystemTest/ILL/D11/002867.nxs.md5 b/Testing/Data/SystemTest/ILL/D11/002867.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..ec41a57079c9634955eef73b442c6d183eb41713
--- /dev/null
+++ b/Testing/Data/SystemTest/ILL/D11/002867.nxs.md5
@@ -0,0 +1 @@
+70372eb2b5dd013159b4d236a3fe96f9
diff --git a/Testing/Data/SystemTest/ILL/D11/002868.nxs.md5 b/Testing/Data/SystemTest/ILL/D11/002868.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..3bdcc9a30eb1ea8842c4e2200c735fadc033769d
--- /dev/null
+++ b/Testing/Data/SystemTest/ILL/D11/002868.nxs.md5
@@ -0,0 +1 @@
+0c6f6b328d6c24219ffc312b98e52595
diff --git a/Testing/Data/SystemTest/ILL/D11/002869.nxs.md5 b/Testing/Data/SystemTest/ILL/D11/002869.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..dd350d2ea7d355ed8ccf1f78956344549b948ef5
--- /dev/null
+++ b/Testing/Data/SystemTest/ILL/D11/002869.nxs.md5
@@ -0,0 +1 @@
+8c988d99461a7f36de37dfe2d6b5973c
diff --git a/Testing/Data/SystemTest/ILL/D11/002870.nxs.md5 b/Testing/Data/SystemTest/ILL/D11/002870.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..23c0142df9002895e316c47ae2199dace6dee29f
--- /dev/null
+++ b/Testing/Data/SystemTest/ILL/D11/002870.nxs.md5
@@ -0,0 +1 @@
+81b06aae8be76a1d76c943456e78e989
diff --git a/Testing/Data/SystemTest/ILL/D11/002871.nxs.md5 b/Testing/Data/SystemTest/ILL/D11/002871.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..34e4cac3aac7d7414d17cb5a55f5a28e6e460f64
--- /dev/null
+++ b/Testing/Data/SystemTest/ILL/D11/002871.nxs.md5
@@ -0,0 +1 @@
+4816c2d31b75a552d903885e01498385
diff --git a/Testing/Data/SystemTest/ILL/D11/002878.nxs.md5 b/Testing/Data/SystemTest/ILL/D11/002878.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..9f3bbcfed330b023495229c58dc236c1041e073c
--- /dev/null
+++ b/Testing/Data/SystemTest/ILL/D11/002878.nxs.md5
@@ -0,0 +1 @@
+57be2fd2dd38dc99a0e5f64d4d0519e3
diff --git a/Testing/Data/SystemTest/ILL/D11/002879.nxs.md5 b/Testing/Data/SystemTest/ILL/D11/002879.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..04c26db748a83e1536d544ed0a8711bb09f69319
--- /dev/null
+++ b/Testing/Data/SystemTest/ILL/D11/002879.nxs.md5
@@ -0,0 +1 @@
+ee48c20d4ae3129ef42a8d8fd305a43c
diff --git a/Testing/Data/SystemTest/ILL/D11/002880.nxs.md5 b/Testing/Data/SystemTest/ILL/D11/002880.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..fccd296bdee6a3b1fe08407d180bd18f4f2a44c8
--- /dev/null
+++ b/Testing/Data/SystemTest/ILL/D11/002880.nxs.md5
@@ -0,0 +1 @@
+d9df0abe4211e0ab2d6a663bc4110089
diff --git a/Testing/Data/SystemTest/ILL/D11/002881.nxs.md5 b/Testing/Data/SystemTest/ILL/D11/002881.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..ddc3bebf2854957a894e905e8211e5bcea31705f
--- /dev/null
+++ b/Testing/Data/SystemTest/ILL/D11/002881.nxs.md5
@@ -0,0 +1 @@
+6fc09449a006f6fbf9b844077bd24e35
diff --git a/Testing/Data/SystemTest/ILL/D11/002883.nxs.md5 b/Testing/Data/SystemTest/ILL/D11/002883.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..d07bd34c48682332939e1f74238ea4f776a0eba5
--- /dev/null
+++ b/Testing/Data/SystemTest/ILL/D11/002883.nxs.md5
@@ -0,0 +1 @@
+96da95f0de38b148f032f68c0336ef62
diff --git a/Testing/Data/SystemTest/ILL/D11/002884.nxs.md5 b/Testing/Data/SystemTest/ILL/D11/002884.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..f6acc0b48706c1a94a819564de479b8dd55360f4
--- /dev/null
+++ b/Testing/Data/SystemTest/ILL/D11/002884.nxs.md5
@@ -0,0 +1 @@
+4bac48284459100fb122328f240ca84f
diff --git a/Testing/Data/SystemTest/ILL/D11/002885.nxs.md5 b/Testing/Data/SystemTest/ILL/D11/002885.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..42f7d7582e4b6bdce9d90c17ec69475b76a06b26
--- /dev/null
+++ b/Testing/Data/SystemTest/ILL/D11/002885.nxs.md5
@@ -0,0 +1 @@
+06dbd4beede52c8504bc8b95eb7f0dca
diff --git a/Testing/Data/SystemTest/ILL/D11/002887.nxs.md5 b/Testing/Data/SystemTest/ILL/D11/002887.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..0ae40d1692162ad0297b6c920efd44fa908111fd
--- /dev/null
+++ b/Testing/Data/SystemTest/ILL/D11/002887.nxs.md5
@@ -0,0 +1 @@
+4c0820b0e1f2b1de761d0b2f914cfa98
diff --git a/Testing/Data/SystemTest/ILL/D11/002888.nxs.md5 b/Testing/Data/SystemTest/ILL/D11/002888.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..5d34e6f5a2321bd649cc43ec14a49bf6cf568e3e
--- /dev/null
+++ b/Testing/Data/SystemTest/ILL/D11/002888.nxs.md5
@@ -0,0 +1 @@
+0b19befd46943b9d68b29f9681c360ad
diff --git a/Testing/Data/SystemTest/ILL/D11/002889.nxs.md5 b/Testing/Data/SystemTest/ILL/D11/002889.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..98799d8d13a4e85248872b7681cda04a265f4bb1
--- /dev/null
+++ b/Testing/Data/SystemTest/ILL/D11/002889.nxs.md5
@@ -0,0 +1 @@
+c7100ee0208167bc7c10e4d9ab015d36
diff --git a/Testing/Data/SystemTest/ILL/D11/002949.nxs.md5 b/Testing/Data/SystemTest/ILL/D11/002949.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..236cf416f94bc34b8d194361bd7ac7f08c93fc72
--- /dev/null
+++ b/Testing/Data/SystemTest/ILL/D11/002949.nxs.md5
@@ -0,0 +1 @@
+9689ff35560d3277fcc87386bd37b760
diff --git a/Testing/Data/SystemTest/ILL/D11/002954.nxs.md5 b/Testing/Data/SystemTest/ILL/D11/002954.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..d0c0cb011dda635134e81748515394749f94dea9
--- /dev/null
+++ b/Testing/Data/SystemTest/ILL/D11/002954.nxs.md5
@@ -0,0 +1 @@
+9f14dcd99b0c5c7ae4b7effc6f2b3a2f
diff --git a/Testing/Data/SystemTest/ILL/D11/002960.nxs.md5 b/Testing/Data/SystemTest/ILL/D11/002960.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..4185b53d09aa7e4f511e65768a89a3bd1168fe59
--- /dev/null
+++ b/Testing/Data/SystemTest/ILL/D11/002960.nxs.md5
@@ -0,0 +1 @@
+149c701e402554f666ef1b243e0cd7e2
diff --git a/Testing/Data/SystemTest/ILL/D11/002971.nxs.md5 b/Testing/Data/SystemTest/ILL/D11/002971.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..de7230e199d23b2878ee675869abda9420405bb9
--- /dev/null
+++ b/Testing/Data/SystemTest/ILL/D11/002971.nxs.md5
@@ -0,0 +1 @@
+b8a1fecf78285426989303488d4d1bb8
diff --git a/Testing/Data/SystemTest/ILL/D11/003167.nxs.md5 b/Testing/Data/SystemTest/ILL/D11/003167.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..4e9fd11faa58b20f6725c9cedb6c2d97a60fc40e
--- /dev/null
+++ b/Testing/Data/SystemTest/ILL/D11/003167.nxs.md5
@@ -0,0 +1 @@
+9bb3a7d7630cf015431fa2d7ecbdba08
diff --git a/Testing/Data/SystemTest/ILL/D11/003172.nxs.md5 b/Testing/Data/SystemTest/ILL/D11/003172.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..b0f0302d5f580839e860d7f6a86f60e841792943
--- /dev/null
+++ b/Testing/Data/SystemTest/ILL/D11/003172.nxs.md5
@@ -0,0 +1 @@
+06f3e3fd8394a682aeb8b1be51c998cb
diff --git a/Testing/Data/SystemTest/ILL/D11/003177.nxs.md5 b/Testing/Data/SystemTest/ILL/D11/003177.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..77d0ff6339f989797485709a08e0b1600488abac
--- /dev/null
+++ b/Testing/Data/SystemTest/ILL/D11/003177.nxs.md5
@@ -0,0 +1 @@
+979dcc91a0a0cf543e0ea7ee9ddea52d
diff --git a/Testing/Data/SystemTest/ILL/D11/003187.nxs.md5 b/Testing/Data/SystemTest/ILL/D11/003187.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..6c787b0e71d32419d47251130dc408e83ee78cb1
--- /dev/null
+++ b/Testing/Data/SystemTest/ILL/D11/003187.nxs.md5
@@ -0,0 +1 @@
+839daf35d5f82e7131d296d8d4d71cc9
diff --git a/Testing/Data/SystemTest/ILL/D11/mask1.nxs.md5 b/Testing/Data/SystemTest/ILL/D11/mask1.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..d5173eaf008d3431b22418b67bee1312e0bc0afa
--- /dev/null
+++ b/Testing/Data/SystemTest/ILL/D11/mask1.nxs.md5
@@ -0,0 +1 @@
+0df395d5e81fd49e470342a1e8dd18c1
diff --git a/Testing/Data/SystemTest/ILL/D11/mask2.nxs.md5 b/Testing/Data/SystemTest/ILL/D11/mask2.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..9f79a5c4a214fbc5b95bd7b726724214870ab389
--- /dev/null
+++ b/Testing/Data/SystemTest/ILL/D11/mask2.nxs.md5
@@ -0,0 +1 @@
+66c16fe62d3a1282956c5c438f28d557
diff --git a/Testing/Data/SystemTest/ILL/D11/mask3.nxs.md5 b/Testing/Data/SystemTest/ILL/D11/mask3.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..6a5a533f76f793e15480a2274581ff5b8c32a56f
--- /dev/null
+++ b/Testing/Data/SystemTest/ILL/D11/mask3.nxs.md5
@@ -0,0 +1 @@
+b3f5134ace660b3ff88361927fd08480
diff --git a/Testing/Data/SystemTest/ILL/D11/sens-lamp.nxs.md5 b/Testing/Data/SystemTest/ILL/D11/sens-lamp.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..fc0d40ef75aadaee5072272875b8658900db0296
--- /dev/null
+++ b/Testing/Data/SystemTest/ILL/D11/sens-lamp.nxs.md5
@@ -0,0 +1 @@
+e830eedaa1fbfb93dd90579d0f98dd1e
diff --git a/Testing/SystemTests/tests/analysis/SANSILLAutoProcessTest.py b/Testing/SystemTests/tests/analysis/SANSILLAutoProcessTest.py
new file mode 100644
index 0000000000000000000000000000000000000000..712b336efd46c9bcf90bcbb510ee79ecb6ed9a37
--- /dev/null
+++ b/Testing/SystemTests/tests/analysis/SANSILLAutoProcessTest.py
@@ -0,0 +1,60 @@
+# Mantid Repository : https://github.com/mantidproject/mantid
+#
+# Copyright © 2018 ISIS Rutherford Appleton Laboratory UKRI,
+# NScD Oak Ridge National Laboratory, European Spallation Source
+# & Institut Laue - Langevin
+# SPDX - License - Identifier: GPL - 3.0 +
+from __future__ import (absolute_import, division, print_function)
+
+import systemtesting
+from mantid.simpleapi import SANSILLAutoProcess, config, mtd, GroupWorkspaces
+
+
+class D11_AutoProcess_Test(systemtesting.MantidSystemTest):
+
+ def __init__(self):
+ super(D11_AutoProcess_Test, self).__init__()
+ self.setUp()
+
+ def setUp(self):
+ config['default.facility'] = 'ILL'
+ config['default.instrument'] = 'D11'
+ config['logging.loggers.root.level'] = 'Warning'
+ config.appendDataSearchSubDir('ILL/D11/')
+
+ def tearDown(self):
+ mtd.clear()
+
+ def validate(self):
+ self.tolerance = 1e-3
+ self.tolerance_is_rel_err = True
+ return ['out', 'D11_AutoProcess_Reference.nxs']
+
+ def runTest(self):
+
+ beams = '2866,2867+2868,2878'
+ containers = '2888+2971,2884+2960,2880+2949'
+ container_tr = '2870+2954'
+ beam_tr = '2867+2868'
+ samples = ['2889,2885,2881',
+ '2887,2883,2879',
+ '3187,3177,3167']
+ sample_tr = ['2871', '2869', '3172']
+ thick = [0.1, 0.2, 0.2]
+
+ # reduce samples
+ for i in range(len(samples)):
+ SANSILLAutoProcess(
+ SampleRuns=samples[i],
+ BeamRuns=beams,
+ ContainerRuns=containers,
+ MaskFiles='mask1.nxs,mask2.nxs,mask3.nxs',
+ SensitivityMaps='sens-lamp.nxs',
+ SampleTransmissionRuns=sample_tr[i],
+ ContainerTransmissionRuns=container_tr,
+ TransmissionBeamRuns=beam_tr,
+ SampleThickness=thick[i],
+ OutputWorkspace='iq_s' + str(i + 1)
+ )
+
+ GroupWorkspaces(InputWorkspaces=['iq_s1', 'iq_s2', 'iq_s3'], OutputWorkspace='out')
diff --git a/Testing/SystemTests/tests/analysis/reference/D11_AutoProcess_Reference.nxs.md5 b/Testing/SystemTests/tests/analysis/reference/D11_AutoProcess_Reference.nxs.md5
new file mode 100644
index 0000000000000000000000000000000000000000..94fafb8890760da8d5717bbd3706a551c797c5a5
--- /dev/null
+++ b/Testing/SystemTests/tests/analysis/reference/D11_AutoProcess_Reference.nxs.md5
@@ -0,0 +1 @@
+ccb02399a764204a59f770319e0659b9
diff --git a/Testing/SystemTests/tests/analysis/reference/ILL_SANS_D11_IQ.nxs.md5 b/Testing/SystemTests/tests/analysis/reference/ILL_SANS_D11_IQ.nxs.md5
index 0a81887138a9c9312ed7badbd747c469c815b50c..9a3ec18ef1eeb1504e22cdb0569e489d3922ceb2 100644
--- a/Testing/SystemTests/tests/analysis/reference/ILL_SANS_D11_IQ.nxs.md5
+++ b/Testing/SystemTests/tests/analysis/reference/ILL_SANS_D11_IQ.nxs.md5
@@ -1 +1 @@
-8f0d48c0b8c47e8f30b57db49839ed25
+43028d0558d7a557013eb1e3045ab39b
diff --git a/Testing/SystemTests/tests/analysis/reference/ILL_SANS_D22_IQ.nxs.md5 b/Testing/SystemTests/tests/analysis/reference/ILL_SANS_D22_IQ.nxs.md5
index b884a082db4930729f8e83b6a10039edbfe480cd..92016d08b04ec268cf8e46bc3cab8416880ede7e 100644
--- a/Testing/SystemTests/tests/analysis/reference/ILL_SANS_D22_IQ.nxs.md5
+++ b/Testing/SystemTests/tests/analysis/reference/ILL_SANS_D22_IQ.nxs.md5
@@ -1 +1 @@
-4bef18303917b5f1eeadeea9c4ad7769
+22b6add1080501cc99d689031ee43f41
diff --git a/Testing/SystemTests/tests/analysis/reference/ILL_SANS_D33_IQ.nxs.md5 b/Testing/SystemTests/tests/analysis/reference/ILL_SANS_D33_IQ.nxs.md5
index ffa8a018ad3a22e854e2806d0750ba1a6767963f..7339a581de67da6e601c4dc074153deda011975e 100644
--- a/Testing/SystemTests/tests/analysis/reference/ILL_SANS_D33_IQ.nxs.md5
+++ b/Testing/SystemTests/tests/analysis/reference/ILL_SANS_D33_IQ.nxs.md5
@@ -1 +1 @@
-9036b5a4bfc971f214f6e9f2bfbcf28d
+b295d56a6a50850780571e013de71363
diff --git a/Testing/SystemTests/tests/analysis/reference/ILL_SANS_D33_LTOF_IQ.nxs.md5 b/Testing/SystemTests/tests/analysis/reference/ILL_SANS_D33_LTOF_IQ.nxs.md5
index fa8ef5d53cca356f77fcedec380003bfd3cb26f3..2522e7d4d2399e9c34c1d3b02b5e28b8f88723a8 100644
--- a/Testing/SystemTests/tests/analysis/reference/ILL_SANS_D33_LTOF_IQ.nxs.md5
+++ b/Testing/SystemTests/tests/analysis/reference/ILL_SANS_D33_LTOF_IQ.nxs.md5
@@ -1 +1 @@
-32b3e360ed4f51761dd9a23c9f71ea9e
+c5806ff289823dbf00599957cd1a6010
diff --git a/Testing/SystemTests/tests/analysis/reference/ILL_SANS_D33_VTOF_IQ.nxs.md5 b/Testing/SystemTests/tests/analysis/reference/ILL_SANS_D33_VTOF_IQ.nxs.md5
index ca2cbe32d4a12800da9be44fb6f8f03c01bb2566..dacef36e1d88d7cb11b53b0c6be96cd8ccce40f0 100644
--- a/Testing/SystemTests/tests/analysis/reference/ILL_SANS_D33_VTOF_IQ.nxs.md5
+++ b/Testing/SystemTests/tests/analysis/reference/ILL_SANS_D33_VTOF_IQ.nxs.md5
@@ -1 +1 @@
-2cc812503f5c3b4f8cbb8c1f70101722
+2bd81479a7dc78e2872d562c1392fe03
diff --git a/docs/source/algorithms/SANSILLAutoProcess-v1.rst b/docs/source/algorithms/SANSILLAutoProcess-v1.rst
new file mode 100644
index 0000000000000000000000000000000000000000..a2929d0e15b87e95c6b7735bdb67cb5714bf8236
--- /dev/null
+++ b/docs/source/algorithms/SANSILLAutoProcess-v1.rst
@@ -0,0 +1,92 @@
+.. algorithm::
+
+.. summary::
+
+.. relatedalgorithms::
+
+.. properties::
+
+Description
+-----------
+
+This algorithms performs complete treatment of SANS data recorded with the ILL instruments D11, D22 and D33.
+This high level algorithm steers the reduction and performs the full set of corrections for a given sample run; measured with one or more detector distances.
+It has two operation modes: *ReduceSample* (default) and *ReduceWater* as follows:
+
+ReduceSample
+------------
+
+This mode is used to correct the sample measurement and convert it to Q-space, producing by default the azimuthal average curve :math:`I(Q)`.
+
+ReduceWater
+-----------
+
+This mode should be used to process water reference measurement in order to derive the relative inter-pixel sensitivity map of the detector.
+This mode will produce two outputs; the regular output will contain fully corrected water run, and there will be an additional output containing the sensitivity map itself.
+The sensitivity map can be saved out to a file and used for sample reductions.
+
+Caching with ADS
+----------------
+
+This algorithm **does not** clean-up the intermediate workspaces after execution. This is done intentionally for performance reasons.
+For example, once the transmission of a sample is calculated, it will be reused for further iterations of processing of the same sample at different detector distances.
+As other example, once the container is processed at a certain distance, it will be reused for all the subsequent samples measured at the same distance, if the container run is the same.
+The same caching is done for absorber, empty beam, container, sensitivity and mask workspaces.
+The caching relies on Analysis Data Service (ADS) through naming convention by appending the relevant process name to the run number.
+When multiple runs are summed, the run number of the first run is attributed to the summed workspace name.
+
+.. include:: ../usagedata-note.txt
+
+**Example - full treatment of 3 samples at 3 different distances**
+
+.. testsetup:: ExSANSILLAutoProcess
+
+ config['default.facility'] = 'ILL'
+ config.appendDataSearchSubDir('ILL/D11/')
+
+.. testcode:: ExSANSILLAutoProcess
+
+ beams = '2866,2867+2868,2878'
+ containers = '2888+2971,2884+2960,2880+2949'
+ container_tr = '2870+2954'
+ beam_tr = '2867+2868'
+ samples = ['2889,2885,2881',
+ '2887,2883,2879',
+ '3187,3177,3167']
+ sample_tr = ['2871', '2869', '3172']
+ thick = [0.1, 0.2, 0.2]
+
+ # reduce samples
+ for i in range(len(samples)):
+ SANSILLAutoProcess(
+ SampleRuns=samples[i],
+ BeamRuns=beams,
+ ContainerRuns=containers,
+ MaskFiles='mask1.nxs,mask2.nxs,mask3.nxs',
+ SensitivityMaps='sens-lamp.nxs',
+ SampleTransmissionRuns=sample_tr[i],
+ ContainerTransmissionRuns=container_tr,
+ TransmissionBeamRuns=beam_tr,
+ SampleThickness=thick[i],
+ OutputWorkspace='iq_s' + str(i + 1)
+ )
+
+ print('Distance 1 Q-range:{0:4f}-{1:4f} AA'.format(mtd['iq_s1_1'].readX(0)[0], mtd['iq_s1_1'].readX(0)[-1]))
+ print('Distance 2 Q-range:{0:4f}-{1:4f} AA'.format(mtd['iq_s1_2'].readX(0)[0], mtd['iq_s1_2'].readX(0)[-1]))
+ print('Distance 3 Q-range:{0:4f}-{1:4f} AA'.format(mtd['iq_s1_3'].readX(0)[0], mtd['iq_s1_3'].readX(0)[-1]))
+
+Output:
+
+.. testoutput:: ExSANSILLAutoProcess
+
+ Distance 1 Q-range:0.001386-0.020065 AA
+ Distance 2 Q-range:0.007000-0.091962 AA
+ Distance 3 Q-range:0.032726-0.343775 AA
+
+.. testcleanup:: ExSANSILLAutoProcess
+
+ mtd.clear()
+
+.. categories::
+
+.. sourcelink::
diff --git a/docs/source/algorithms/SANSILLReduction-v1.rst b/docs/source/algorithms/SANSILLReduction-v1.rst
index 54bb6565bad1a9ed5d5c57d8af75c62de5959893..17b15429791435d3d45c662bcbd75ae728fd22cc 100644
--- a/docs/source/algorithms/SANSILLReduction-v1.rst
+++ b/docs/source/algorithms/SANSILLReduction-v1.rst
@@ -190,10 +190,10 @@ Output:
.. testoutput:: ExSANSILLReduction
- Water container transmission is 0.945
- Water transmission is 0.500
- Sample container transmission is 0.665
- Sample transmission is 0.640
+ Water container transmission is 0.946
+ Water transmission is 0.501
+ Sample container transmission is 0.667
+ Sample transmission is 0.642
.. testcleanup:: ExSANSILLReduction
diff --git a/docs/source/release/v4.1.0/sans.rst b/docs/source/release/v4.1.0/sans.rst
index 719875afbeafde5ebcee4de703671f0569fcbbe7..8c47a9ebb65e91aee2d4a239885e41a9d5baede6 100644
--- a/docs/source/release/v4.1.0/sans.rst
+++ b/docs/source/release/v4.1.0/sans.rst
@@ -57,6 +57,7 @@ New
- New IDF for ``EQ-SANS``
- New algorithm :ref:`LoadHFIRSANS <algm-LoadHFIRSANS>` and speed improvements to :ref:`LoadSpice2D <algm-LoadSpice2D>`
- New version of algorithm :ref:`CalculateEfficiency <algm-CalculateEfficiency-v2>`
+- New algorithm :ref:`SANSILLAutoProcess <algm-SANSILLAutoProcess>` will perform the full SANS treatment for ILL instruments.
Improved
########
diff --git a/instrument/D11_Definition.xml b/instrument/D11_Definition.xml
index 417408aff6568d0c4e671831f1a58ef6d993cc0b..ec5d63164a67a8f23d18a613609fa9ec991da205 100644
--- a/instrument/D11_Definition.xml
+++ b/instrument/D11_Definition.xml
@@ -1,5 +1,5 @@
<?xml version='1.0' encoding='ASCII'?>
-<instrument xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.mantidproject.org/IDF/1.0" last-modified="2018-04-26 11:25:14.536260" name="D11" valid-from="2017-10-01 23:59:59" valid-to="2100-01-31 23:59:59" xsi:schemaLocation="http://www.mantidproject.org/IDF/1.0 http://schema.mantidproject.org/IDF/1.0/IDFSchema.xsd">
+<instrument xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.mantidproject.org/IDF/1.0" last-modified="2019-07-11 10:44:30.057138" name="D11" valid-from="2017-10-01 23:59:59" valid-to="2100-01-31 23:59:59" xsi:schemaLocation="http://www.mantidproject.org/IDF/1.0 http://schema.mantidproject.org/IDF/1.0/IDFSchema.xsd">
<!-- This is the instrument definition file of the D11 Lowest momentum transfer & lowest background
small-angle neutron scattering instrument at the ILL.
Generated file, PLEASE DO NOT EDIT THIS FILE!
@@ -48,6 +48,7 @@
<pointing-up axis="y"/>
<handedness val="right"/>
</reference-frame>
+ <default-view axis-view="z-" view="3D"/>
</defaults>
<!--SOURCE-->
<component type="moderator">
@@ -89,16 +90,15 @@
<component idfillbyfirst="y" idstart="0" idstepbyrow="256" type="detector">
<location x="0.0" y="0.0" z="1.2"/>
</component>
- <type is="rectangular_detector" name="detector" type="pixel" xpixels="256" xstart="-0.47812499999999997" xstep="0.00375" ypixels="256" ystart="-0.47812499999999997" ystep="0.00375"/>
+ <type is="rectangular_detector" name="detector" type="pixel" xpixels="256" xstart="0.47812499999999997" xstep="-0.00375" ypixels="256" ystart="-0.47812499999999997" ystep="0.00375"/>
<!--PIXEL, EACH PIXEL IS A DETECTOR-->
<type is="detector" name="pixel">
<cuboid id="pixel-shape">
- <left-front-bottom-point x="-0.001875" y="-0.001875" z="0.0"/>
- <left-front-top-point x="0.001875" y="0.001875" z="0.0"/>
- <left-back-bottom-point x="-0.001875" y="-0.001875" z="-0.0001"/>
- <right-front-bottom-point x="0.001875" y="-0.001875" z="0.0"/>
+ <left-front-bottom-point x="-0.001875" y="-0.001875" z="5e-05"/>
+ <left-front-top-point x="-0.001875" y="0.001875" z="5e-05"/>
+ <left-back-bottom-point x="-0.001875" y="-0.001875" z="-5e-05"/>
+ <right-front-bottom-point x="0.001875" y="-0.001875" z="5e-05"/>
</cuboid>
<algebra val="pixel-shape"/>
</type>
</instrument>
-
diff --git a/instrument/D11_Parameters.xml b/instrument/D11_Parameters.xml
index 216520412d3191dcfa2b877e8784aea7daa24e14..e170b34c96dd6012b77375ba85d5ce333b0056da 100644
--- a/instrument/D11_Parameters.xml
+++ b/instrument/D11_Parameters.xml
@@ -14,6 +14,13 @@
<parameter name="grouping" type="string">
<value val="0-65535"/>
</parameter>
+ <!-- The pixel sizes used by SolidAngle -->
+ <parameter name="x-pixel-size" type="number">
+ <value val="3.75"/>
+ </parameter>
+ <parameter name="y-pixel-size" type="number">
+ <value val="3.75"/>
+ </parameter>
</component-link>
</parameter-file>
diff --git a/instrument/D11lr_Definition.xml b/instrument/D11lr_Definition.xml
index cfb10c0357fbc6852fe91776fb219cf0c08c2b20..6b676a866fb196a057bc4c02f2bf2e79b0a5a122 100644
--- a/instrument/D11lr_Definition.xml
+++ b/instrument/D11lr_Definition.xml
@@ -1,5 +1,5 @@
<?xml version='1.0' encoding='ASCII'?>
-<instrument xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.mantidproject.org/IDF/1.0" last-modified="2018-04-26 11:25:32.985566" name="D11lr" valid-from="2017-10-01 23:59:59" valid-to="2100-01-31 23:59:59" xsi:schemaLocation="http://www.mantidproject.org/IDF/1.0 http://schema.mantidproject.org/IDF/1.0/IDFSchema.xsd">
+<instrument xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.mantidproject.org/IDF/1.0" last-modified="2019-07-11 10:45:12.505447" name="D11lr" valid-from="2017-10-01 23:59:59" valid-to="2100-01-31 23:59:59" xsi:schemaLocation="http://www.mantidproject.org/IDF/1.0 http://schema.mantidproject.org/IDF/1.0/IDFSchema.xsd">
<!-- This is the instrument definition file of the D11 Lowest momentum transfer & lowest background
small-angle neutron scattering instrument at the ILL.
Generated file, PLEASE DO NOT EDIT THIS FILE!
@@ -48,6 +48,7 @@
<pointing-up axis="y"/>
<handedness val="right"/>
</reference-frame>
+ <default-view axis-view="z-" view="3D"/>
</defaults>
<!--SOURCE-->
<component type="moderator">
@@ -89,16 +90,15 @@
<component idfillbyfirst="y" idstart="0" idstepbyrow="128" type="detector">
<location x="0.0" y="0.0" z="1.2"/>
</component>
- <type is="rectangular_detector" name="detector" type="pixel" xpixels="128" xstart="-0.47625" xstep="0.0075" ypixels="128" ystart="-0.47625" ystep="0.0075"/>
+ <type is="rectangular_detector" name="detector" type="pixel" xpixels="128" xstart="0.47625" xstep="-0.0075" ypixels="128" ystart="-0.47625" ystep="0.0075"/>
<!--PIXEL, EACH PIXEL IS A DETECTOR-->
<type is="detector" name="pixel">
<cuboid id="pixel-shape">
- <left-front-bottom-point x="-0.00375" y="-0.00375" z="0.0"/>
- <left-front-top-point x="0.00375" y="0.00375" z="0.0"/>
- <left-back-bottom-point x="-0.00375" y="-0.00375" z="-0.0001"/>
- <right-front-bottom-point x="0.00375" y="-0.00375" z="0.0"/>
+ <left-front-bottom-point x="-0.00375" y="-0.00375" z="5e-05"/>
+ <left-front-top-point x="-0.00375" y="0.00375" z="5e-05"/>
+ <left-back-bottom-point x="-0.00375" y="-0.00375" z="-5e-05"/>
+ <right-front-bottom-point x="0.00375" y="-0.00375" z="5e-05"/>
</cuboid>
<algebra val="pixel-shape"/>
</type>
</instrument>
-
diff --git a/instrument/D11lr_Parameters.xml b/instrument/D11lr_Parameters.xml
index ef72c4458735850984cc65bbd28fc2d7fadd388b..02d096058046b661a658df964e5fdad1bda5725a 100644
--- a/instrument/D11lr_Parameters.xml
+++ b/instrument/D11lr_Parameters.xml
@@ -14,6 +14,13 @@
<parameter name="grouping" type="string">
<value val="0-16383"/>
</parameter>
+ <!-- The pixel sizes used by SolidAngle -->
+ <parameter name="x-pixel-size" type="number">
+ <value val="7.5"/>
+ </parameter>
+ <parameter name="y-pixel-size" type="number">
+ <value val="7.5"/>
+ </parameter>
</component-link>
</parameter-file>
diff --git a/instrument/D22_Definition.xml b/instrument/D22_Definition.xml
index bfd1aa865f3b9cbdd66b1066f4ded9c908033e47..905ec4ea7ea8b7141c83724fba022e20f62d5043 100644
--- a/instrument/D22_Definition.xml
+++ b/instrument/D22_Definition.xml
@@ -1,5 +1,5 @@
<?xml version='1.0' encoding='ASCII'?>
-<instrument xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.mantidproject.org/IDF/1.0" last-modified="2018-04-26 11:23:20.975212" name="D22" valid-from="2017-10-01 23:59:59" valid-to="2100-01-31 23:59:59" xsi:schemaLocation="http://www.mantidproject.org/IDF/1.0 http://schema.mantidproject.org/IDF/1.0/IDFSchema.xsd">
+<instrument xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.mantidproject.org/IDF/1.0" last-modified="2019-07-11 10:49:44.830663" name="D22" valid-from="2017-10-01 23:59:59" valid-to="2100-01-31 23:59:59" xsi:schemaLocation="http://www.mantidproject.org/IDF/1.0 http://schema.mantidproject.org/IDF/1.0/IDFSchema.xsd">
<!-- This is the instrument definition file of the D22 Large dynamic range small-angle diffractometer
at the ILL.
Generated file, PLEASE DO NOT EDIT THIS FILE!
@@ -43,6 +43,7 @@
<pointing-up axis="y"/>
<handedness val="right"/>
</reference-frame>
+ <default-view axis-view="z-" view="3D"/>
</defaults>
<!--SOURCE-->
<component type="moderator">
@@ -88,12 +89,11 @@
<!--PIXEL, EACH PIXEL IS A DETECTOR-->
<type is="detector" name="pixel">
<cuboid id="pixel-shape">
- <left-front-bottom-point x="-0.004" y="-0.002" z="0.0"/>
- <left-front-top-point x="0.004" y="0.002" z="0.0"/>
- <left-back-bottom-point x="-0.004" y="-0.002" z="-0.0001"/>
- <right-front-bottom-point x="0.004" y="-0.002" z="0.0"/>
+ <left-front-bottom-point x="-0.004" y="-0.002" z="5e-05"/>
+ <left-front-top-point x="-0.004" y="0.002" z="5e-05"/>
+ <left-back-bottom-point x="-0.004" y="-0.002" z="-5e-05"/>
+ <right-front-bottom-point x="0.004" y="-0.002" z="5e-05"/>
</cuboid>
<algebra val="pixel-shape"/>
</type>
</instrument>
-
diff --git a/instrument/D22lr_Definition.xml b/instrument/D22lr_Definition.xml
index 4c7d901bc53a7404031411398b367141e90b2b14..efdc35a33180e6766a103435bd46b2e19d7a3bdb 100644
--- a/instrument/D22lr_Definition.xml
+++ b/instrument/D22lr_Definition.xml
@@ -1,5 +1,5 @@
<?xml version='1.0' encoding='ASCII'?>
-<instrument xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.mantidproject.org/IDF/1.0" last-modified="2018-04-26 11:23:43.832671" name="D22lr" valid-from="2017-10-01 23:59:59" valid-to="2100-01-31 23:59:59" xsi:schemaLocation="http://www.mantidproject.org/IDF/1.0 http://schema.mantidproject.org/IDF/1.0/IDFSchema.xsd">
+<instrument xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.mantidproject.org/IDF/1.0" last-modified="2019-07-11 10:49:33.026308" name="D22lr" valid-from="2017-10-01 23:59:59" valid-to="2100-01-31 23:59:59" xsi:schemaLocation="http://www.mantidproject.org/IDF/1.0 http://schema.mantidproject.org/IDF/1.0/IDFSchema.xsd">
<!-- This is the instrument definition file of the D22 Large dynamic range small-angle diffractometer
at the ILL.
Generated file, PLEASE DO NOT EDIT THIS FILE!
@@ -43,6 +43,7 @@
<pointing-up axis="y"/>
<handedness val="right"/>
</reference-frame>
+ <default-view axis-view="z-" view="3D"/>
</defaults>
<!--SOURCE-->
<component type="moderator">
@@ -88,12 +89,11 @@
<!--PIXEL, EACH PIXEL IS A DETECTOR-->
<type is="detector" name="pixel">
<cuboid id="pixel-shape">
- <left-front-bottom-point x="-0.004" y="-0.004" z="0.0"/>
- <left-front-top-point x="0.004" y="0.004" z="0.0"/>
- <left-back-bottom-point x="-0.004" y="-0.004" z="-0.0001"/>
- <right-front-bottom-point x="0.004" y="-0.004" z="0.0"/>
+ <left-front-bottom-point x="-0.004" y="-0.004" z="5e-05"/>
+ <left-front-top-point x="-0.004" y="0.004" z="5e-05"/>
+ <left-back-bottom-point x="-0.004" y="-0.004" z="-5e-05"/>
+ <right-front-bottom-point x="0.004" y="-0.004" z="5e-05"/>
</cuboid>
<algebra val="pixel-shape"/>
</type>
</instrument>
-
diff --git a/instrument/D33_Definition.xml b/instrument/D33_Definition.xml
index 2ec53db882636da0e3351ca2de56a45f70fdd68e..7a3dd9043c312e4aed9f8235ce6e2fd061c9bb50 100644
--- a/instrument/D33_Definition.xml
+++ b/instrument/D33_Definition.xml
@@ -1,5 +1,5 @@
<?xml version='1.0' encoding='ASCII'?>
-<instrument xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.mantidproject.org/IDF/1.0" last-modified="2018-09-25 11:00:25.729603" name="D33" valid-from="2017-10-01 23:59:59" valid-to="2100-01-31 23:59:59" xsi:schemaLocation="http://www.mantidproject.org/IDF/1.0 http://schema.mantidproject.org/IDF/1.0/IDFSchema.xsd">
+<instrument xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.mantidproject.org/IDF/1.0" last-modified="2019-07-11 10:50:50.653599" name="D33" valid-from="2017-10-01 23:59:59" valid-to="2100-01-31 23:59:59" xsi:schemaLocation="http://www.mantidproject.org/IDF/1.0 http://schema.mantidproject.org/IDF/1.0/IDFSchema.xsd">
<!-- This is the instrument definition file of the D33 Massive dynamic q-range small-angle diffractometer
at the ILL.
Generated file, PLEASE DO NOT EDIT THIS FILE!
@@ -51,6 +51,7 @@
<pointing-up axis="y"/>
<handedness val="right"/>
</reference-frame>
+ <default-view axis-view="z-" view="3D"/>
</defaults>
<!--SOURCE-->
<component type="moderator">
@@ -136,10 +137,10 @@
<!--PIXEL, EACH PIXEL IS A DETECTOR-->
<type is="detector" name="pixel">
<cuboid id="pixel-shape">
- <left-front-bottom-point x="-0.00125" y="-0.0025" z="0.0"/>
- <left-front-top-point x="0.00125" y="0.0025" z="0.0"/>
- <left-back-bottom-point x="-0.00125" y="-0.0025" z="-0.0001"/>
- <right-front-bottom-point x="0.00125" y="-0.0025" z="0.0"/>
+ <left-front-bottom-point x="-0.00125" y="-0.0025" z="5e-05"/>
+ <left-front-top-point x="-0.00125" y="0.0025" z="5e-05"/>
+ <left-back-bottom-point x="-0.00125" y="-0.0025" z="-5e-05"/>
+ <right-front-bottom-point x="0.00125" y="-0.0025" z="-5e-05"/>
</cuboid>
<algebra val="pixel-shape"/>
</type>