def test_replace_axis(self):
x_axis = NumericAxis.create(1)
x_axis.setValue(0, 0)
ws1 = WorkspaceCreationHelper.create2DWorkspaceWithFullInstrument(
2, 1, False)
ws1.replaceAxis(0, x_axis)
ws2 = WorkspaceCreationHelper.create2DWorkspaceWithFullInstrument(
2, 1, False)
ws2.replaceAxis(0, x_axis)
try:
del ws1, ws2
except:
self.fail(
"Segmentation violation when deleting the same axis twice")
def test_sort_by_value_not_string(self):
npeaks = 5
peaks_ws = WorkspaceCreationHelper.createPeaksWorkspace(npeaks)
view = PeaksViewerView(None, None)
model = PeaksViewerModel(peaks_ws, fg_color='r', bg_color='w')
presenter = PeaksViewerPresenter(model, view)
table_view = view.table_view
table_model = table_view.model()
# Very difficult to simulate mouse click to sort - trust Qt to do that
# We are more interested that the sort is based on value no a string comparison
# check a few columns
for column_index in (7, 16): # tof & qlab
table_model.sort(column_index, Qt.DescendingOrder)
self.assertEqual(npeaks, view.table_view.rowCount())
# assert sort has happened
col_values = [
table_model.index(i, column_index).data(
PeaksWorkspaceDataPresenter.DATA_SORT_ROLE)
for i in range(npeaks)
]
self.assertTrue(
all(col_values[i + 1] < col_values[i]
for i in range(npeaks - 1)),
msg="TOF values have not been sorted into descending order")
view.close()
del presenter
def testFailLimits(self):
w2=WorkspaceCreationHelper.create2DWorkspaceWithFullInstrument(30,5,False,False)
AnalysisDataService.add('w2',w2)
w3=CloneWorkspace('w2')
w4=CloneWorkspace('w2')
try:
MaskAngle(w2,-100,20)
self.fail("Should not have got here. Wrong angle.")
except RuntimeError:
pass
finally:
DeleteWorkspace('w2')
try:
MaskAngle(w3,10,200)
self.fail("Should not have got here. Wrong angle.")
except ValueError:
pass
finally:
DeleteWorkspace('w3')
try:
MaskAngle(w4,100,20)
self.fail("Should not have got here. Wrong angle.")
except RuntimeError:
pass
finally:
DeleteWorkspace('w4')
def test_addPeak_SpecialCoordinateSystem(self):
r"""Verify we can add peaks in different coordinate systems"""
pws = WorkspaceCreationHelper.createPeaksWorkspace(
numPeaks=0, createOrientedLattice=True)
pws.addPeak([1, 2, 3], SpecialCoordinateSystem.QLab)
pws.addPeak([1, 2, 3], SpecialCoordinateSystem.QSample)
pws.addPeak([1, 2, 3], SpecialCoordinateSystem.HKL)
def test_information_access(self):
signal = 2.0
ndims = 1
expt_ws = WorkspaceCreationHelper.makeFakeMDHistoWorkspace(signal, ndims)
expinfo = expt_ws.getExperimentInfo(0)
self.assertTrue(isinstance(expinfo, ExperimentInfo))
self.assertEqual(1, expt_ws.getNumExperimentInfo())
def test_createPeakHKL(self):
pws = WorkspaceCreationHelper.createPeaksWorkspace(0, True)
lattice = pws.mutableSample().getOrientedLattice()
# Simple test that the creational method is exposed
p = pws.createPeakHKL([1,1,1])
self.assertTrue(IPeak != None)
def test_information_access(self):
signal = 2.0
ndims = 1
expt_ws = WorkspaceCreationHelper.makeFakeMDHistoWorkspace(signal, ndims)
expinfo = expt_ws.getExperimentInfo(0)
self.assertTrue(isinstance(expinfo, ExperimentInfo))
self.assertEquals(1, expt_ws.getNumExperimentInfo())
def test_createPeakHKL(self):
pws = WorkspaceCreationHelper.createPeaksWorkspace(0, True)
lattice = pws.mutableSample().getOrientedLattice()
# Simple test that the creational method is exposed
p = pws.createPeakHKL([1,1,1])
self.assertTrue(IPeak != None)
def test_peak_setQSampleFrame(self):
pws = WorkspaceCreationHelper.createPeaksWorkspace(1, True)
p = pws.getPeak(0)
try:
p.setQSampleFrame(V3D(1, 1, 1))
except Exception:
self.fail("Tried setQSampleFrame with one V3D argument")
self.assertAlmostEquals(p.getQSampleFrame().X(),
-1.4976057446828845,
places=10)
self.assertAlmostEquals(p.getQSampleFrame().Y(),
0.059904229787315376,
places=10)
self.assertAlmostEquals(p.getQSampleFrame().Z(),
1.4400957702126842,
places=10)
try:
p.setQSampleFrame(V3D(1, 1, 1), 1)
except Exception:
self.fail(
"Tried setQSampleFrame with one V3D argument and a double distance"
)
self.assertAlmostEquals(p.getQSampleFrame().X(), 1.0, places=10)
self.assertAlmostEquals(p.getQSampleFrame().Y(), 1.0, places=10)
self.assertAlmostEquals(p.getQSampleFrame().Z(), 1.0, places=10)
def test_hasMaskedBins(self):
numBins = 10
numHist = 11
ws = WorkspaceCreationHelper.create2DWorkspace123WithMaskedBin(
numHist, numBins, 0, 1)
self.assertTrue(ws.hasMaskedBins(0))
self.assertFalse(ws.hasMaskedBins(1))
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 test_maskedBinsIndices(self):
numBins = 10
numHist=11
ws = WorkspaceCreationHelper.create2DWorkspace123WithMaskedBin(numHist, numBins, 0, 1)
maskedBinsIndices = ws.maskedBinsIndices(0)
self.assertEqual(1, len(maskedBinsIndices))
for index in maskedBinsIndices:
self.assertEqual(1, index)
def testGroupMaskAngle(self):
ws1=WorkspaceCreationHelper.create2DWorkspaceWithFullInstrument(30,5,False,False)
AnalysisDataService.add('ws1GMA',ws1)
ws2=WorkspaceCreationHelper.create2DWorkspaceWithFullInstrument(30,5,False,False)
AnalysisDataService.add('ws2GMA',ws2)
group = GroupWorkspaces(['ws1GMA', 'ws2GMA'])
MaskAngle(group, 10, 20)
for w in group:
detInfo = w.detectorInfo()
for i in arange(w.getNumberHistograms()):
if(i<9) or (i>18):
self.assertFalse(detInfo.isMasked(int(i)))
else:
self.assertTrue(detInfo.isMasked(int(i)))
DeleteWorkspace(group)
def test_validate_inputs(self):
test_ws = WorkspaceCreationHelper.create2DWorkspaceWithRectangularInstrument(1, 5, 5)
alg = ReflectometryISISSumBanks()
alg.initialize()
alg.setProperty('InputWorkspace', test_ws)
issues = alg.validateInputs()
self.assertEqual(len(issues), 0)
def test_validate_inputs_fails_if_not_a_rectangular_detector(self):
test_ws = WorkspaceCreationHelper.createEventWorkspaceWithNonUniformInstrument(1, True)
alg = ReflectometryISISSumBanks()
alg.initialize()
alg.setProperty('InputWorkspace', test_ws)
issues = alg.validateInputs()
self.assertEqual(len(issues), 1)
self.assertEqual(issues['InputWorkspace'], 'The input workspace must contain a rectangular detector')
def testMaskAngleInPlane(self):
w_inplane = WorkspaceCreationHelper.create2DWorkspaceWithFullInstrument(30,5,False,False)
AnalysisDataService.add('w_inplane',w_inplane)
MaskAngle(w_inplane,-5,5,Angle='InPlane')
detInfo = w_inplane.detectorInfo()
print('num spectra = {}'.format(w_inplane.getNumberHistograms()))
for i in arange(w_inplane.getNumberHistograms()):
# the entire instrument is at an in-plane angle of zero degrees
self.assertTrue(detInfo.isMasked(int(i)), 'index={}'.format(i))
DeleteWorkspace(w_inplane)
def test_validate_inputs_fails_if_multiple_rectangular_detectors(self):
test_ws = WorkspaceCreationHelper.create2DWorkspaceWithRectangularInstrument(2, 5, 5)
alg = ReflectometryISISSumBanks()
alg.initialize()
alg.setProperty('InputWorkspace', test_ws)
issues = alg.validateInputs()
self.assertEqual(len(issues), 1)
self.assertEqual(issues['InputWorkspace'], 'The input workspace must only contain one rectangular detector: multiple were found')
def testMaskAnglePhi(self):
w=WorkspaceCreationHelper.create2DWorkspaceWithFullInstrument(30,5,False,False)
AnalysisDataService.add('w',w)
MaskAngle(w,0,45,Angle='Phi')
detInfo = w.detectorInfo()
for i in arange(w.getNumberHistograms()):
if i==0:
self.assertTrue(detInfo.isMasked(int(i)))
else:
self.assertFalse(detInfo.isMasked(int(i)))
DeleteWorkspace(w)
def testMaskAngle(self):
w=WorkspaceCreationHelper.create2DWorkspaceWithFullInstrument(30,5,False,False)
AnalysisDataService.add('w',w)
masklist = MaskAngle(w,MinAngle=10,MaxAngle=20)
detInfo = w.detectorInfo()
for i in arange(w.getNumberHistograms()):
if (i<9) or (i>18):
self.assertFalse(detInfo.isMasked(int(i)))
else:
self.assertTrue(detInfo.isMasked(int(i)))
DeleteWorkspace(w)
self.assertTrue(array_equal(masklist,arange(10)+10))
def test_peak_setQSampleFrame(self):
pws = WorkspaceCreationHelper.createPeaksWorkspace(1, True)
p = pws.getPeak(0)
try:
p.setQSampleFrame(V3D(1,1,1))
except Exception:
self.fail("Tried setQSampleFrame with one V3D argument")
try:
p.setQSampleFrame(V3D(1,1,1), 1)
except Exception:
self.fail("Tried setQSampleFrame with one V3D argument and a double distance")
def test_setCell_with_column_name(self):
pws = WorkspaceCreationHelper.createPeaksWorkspace(1, True)
pws.setCell("h", 0, 1)
pws.setCell("k", 0, 2)
pws.setCell("l", 0, 3)
pws.setCell("QLab", 0, V3D(1,1,1))
pws.setCell("QSample", 0, V3D(1,1,1))
self.assertEquals(pws.cell("h", 0), 1)
self.assertEquals(pws.cell("k", 0), 2)
self.assertEquals(pws.cell("l", 0), 3)
self.assertEquals(pws.cell("QLab", 0), V3D(1,1,1))
self.assertEquals(pws.cell("QSample", 0), V3D(1,1,1))
def testMaskBTPWrongInstrument(self):
w = WorkspaceCreationHelper.create2DWorkspaceWithFullInstrument(
30, 5, False, False)
AnalysisDataService.add('w', w)
try:
MaskBTP(Workspace=w, Pixel="1")
self.fail(
"Should not have got here. Should throw because wrong instrument."
)
except RuntimeError:
pass
finally:
DeleteWorkspace(w)
def test_setCell_with_column_name(self):
pws = WorkspaceCreationHelper.createPeaksWorkspace(1, True)
pws.setCell("h", 0, 1)
pws.setCell("k", 0, 2)
pws.setCell("l", 0, 3)
pws.setCell("QLab", 0, V3D(1,1,1))
pws.setCell("QSample", 0, V3D(1,1,1))
self.assertEquals(pws.cell("h", 0), 1)
self.assertEquals(pws.cell("k", 0), 2)
self.assertEquals(pws.cell("l", 0), 3)
self.assertEquals(pws.cell("QLab", 0), V3D(1,1,1))
self.assertEquals(pws.cell("QSample", 0), V3D(1,1,1))
def test_iteration_support(self):
pws = WorkspaceCreationHelper.createPeaksWorkspace(0, True)
hkls = ([1, 1, 1], [2, 1, 1], [1, 2, 1])
for hkl in hkls:
pws.addPeak(pws.createPeakHKL(hkl))
count = 0
for index, peak in enumerate(pws):
count += 1
self.assertTrue(isinstance(peak, IPeak))
self.assertAlmostEqual(V3D(*hkls[index]), peak.getHKL())
self.assertEquals(len(hkls), count)
def test_peak_setQSampleFrame(self):
pws = WorkspaceCreationHelper.createPeaksWorkspace(1, True)
p = pws.getPeak(0)
try:
p.setQSampleFrame(V3D(1, 1, 1))
except Exception:
self.fail("Tried setQSampleFrame with one V3D argument")
try:
p.setQSampleFrame(V3D(1, 1, 1), 1)
except Exception:
self.fail(
"Tried setQSampleFrame with one V3D argument and a double distance"
)
def testGroupFailNoInstrument(self):
ws1=WorkspaceCreationHelper.create2DWorkspaceWithFullInstrument(30,5,False,False)
AnalysisDataService.add('ws1GFNI',ws1)
ws2 = CreateWorkspace(arange(5), arange(5))
AnalysisDataService.add('ws2GFNI',ws2)
group = GroupWorkspaces(['ws1GFNI', 'ws2GFNI'])
try:
MaskAngle(group, 10, 20)
self.fail("Should not have gotten here. Should throw because no instrument.")
except (RuntimeError, ValueError, TypeError):
pass
finally:
DeleteWorkspace(group)
def test_RectangularDetector_getattributes(self):
testws = WorkspaceCreationHelper.create2DWorkspaceWithRectangularInstrument(3,5,5)
i = testws.getInstrument()
self.assertEquals(i[2].getName(),'bank3')
self.assertEquals(i[2][2].getName(),'bank3(x=2)')
self.assertEquals(i[2][2][2].getName(),'bank3(2,2)')
self.assertEquals(i[2].nelements(),5)
self.assertEquals(i[2].xstart()+i[2].xstep()*i[2].xpixels(),0.04)
self.assertEquals(i[1].ystart()+i[1].ystep()*i[1].ypixels(),0.04)
self.assertEquals(i[0].xsize(),0.04)
self.assertEquals(i[2].idstart(),75)
self.assertEquals(i[0].idstep(),1)
self.assertEquals(i[1].idstepbyrow(),5)
self.assertEquals(i[1].maxDetectorID(),74)
self.assertEquals(i[1].minDetectorID(),50)
def test_RectangularDetector_getattributes(self):
testws = WorkspaceCreationHelper.create2DWorkspaceWithRectangularInstrument(3, 5, 5)
i = testws.getInstrument()
self.assertEquals(i[2].getName(), "bank3")
self.assertEquals(i[2][2].getName(), "bank3(x=2)")
self.assertEquals(i[2][2][2].getName(), "bank3(2,2)")
self.assertEquals(i[2].nelements(), 5)
self.assertEquals(i[2].xstart() + i[2].xstep() * i[2].xpixels(), 0.04)
self.assertEquals(i[1].ystart() + i[1].ystep() * i[1].ypixels(), 0.04)
self.assertEquals(i[0].xsize(), 0.04)
self.assertEquals(i[2].idstart(), 75)
self.assertEquals(i[0].idstep(), 1)
self.assertEquals(i[1].idstepbyrow(), 5)
self.assertEquals(i[1].maxDetectorID(), 74)
self.assertEquals(i[1].minDetectorID(), 50)
def testSortDetectors(self):
w = WorkspaceCreationHelper.create2DWorkspaceWithFullInstrument(
10, 2, False, False)
AnalysisDataService.add('w', w)
MoveInstrumentComponent(w,
DetectorID=3,
X=0.,
Y=0,
Z=-7.,
RelativePosition=0)
x = SortDetectors(w)
DeleteWorkspace(w)
self.assertTrue(array_equal(x[0], array([2])))
self.assertTrue(array_equal(x[1], array([7.])))
self.assertTrue(array_equal(x[2], array([0, 1, 3, 4, 5, 6, 7, 8, 9])))
self.assertEqual(x[3][0], 5.)
def test_MaskWorkspace_Is_Retrievable(self):
dummy_ws = WorkspaceCreationHelper.create2DWorkspaceWithFullInstrument(2, 102, False) # no monitors
ws_name = "dummy"
AnalysisDataService.add(ws_name, dummy_ws)
run_algorithm('MaskDetectors', Workspace=ws_name, WorkspaceIndexList=1)
mask_name = 'mask_ws'
run_algorithm('ExtractMask', InputWorkspace=ws_name, OutputWorkspace=mask_name)
masked_ws = AnalysisDataService[mask_name]
self.assertTrue(isinstance(masked_ws, IMaskWorkspace))
self.assertEqual(1, masked_ws.getNumberMasked())
# single number
self.assertTrue(not masked_ws.isMasked(1))
self.assertTrue(masked_ws.isMasked(2))
# list
self.assertTrue(not masked_ws.isMasked([1]))
self.assertTrue(masked_ws.isMasked([2]))
def test_MaskWorkspace_Is_Retrievable(self):
dummy_ws = WorkspaceCreationHelper.create2DWorkspaceWithFullInstrument(2, 102, False) # no monitors
ws_name = "dummy"
AnalysisDataService.add(ws_name, dummy_ws)
run_algorithm('MaskDetectors', Workspace=ws_name, WorkspaceIndexList=1)
mask_name = 'mask_ws'
run_algorithm('ExtractMask', InputWorkspace=ws_name, OutputWorkspace=mask_name)
masked_ws = AnalysisDataService[mask_name]
self.assertTrue(isinstance(masked_ws, IMaskWorkspace))
self.assertEqual(1, masked_ws.getNumberMasked())
# single number
self.assertTrue(not masked_ws.isMasked(1))
self.assertTrue(masked_ws.isMasked(2))
# list
self.assertTrue(not masked_ws.isMasked([1]))
self.assertTrue(masked_ws.isMasked([2]))
def test_peak_setQLabFrame(self):
pws = WorkspaceCreationHelper.createPeaksWorkspace(1, True)
p = pws.getPeak(0)
try:
p.setQLabFrame(V3D(1,1,1))
except Exception:
self.fail("Tried setQLabFrame with one V3D argument")
self.assertAlmostEquals( p.getQLabFrame().X(), 1.0, places=10)
self.assertAlmostEquals( p.getQLabFrame().Y(), 1.0, places=10)
self.assertAlmostEquals( p.getQLabFrame().Z(), 1.0, places=10)
try:
p.setQLabFrame(V3D(1,1,1), 1)
except Exception:
self.fail("Tried setQLabFrame with one V3D argument and a double distance")
self.assertAlmostEquals( p.getQLabFrame().X(), 1.0, places=10)
self.assertAlmostEquals( p.getQLabFrame().Y(), 1.0, places=10)
self.assertAlmostEquals( p.getQLabFrame().Z(), 1.0, places=10)
def test_interface(self):
""" Rudimentary test to get peak and get/set some values """
pws = WorkspaceCreationHelper.createPeaksWorkspace(1)
self.assertTrue(isinstance(pws, IPeaksWorkspace))
self.assertEqual(pws.getNumberPeaks(), 1)
p = pws.getPeak(0)
# Try a few IPeak get/setters. Not everything.
p.setH(234)
self.assertEqual(p.getH(), 234)
p.setHKL(5,6,7)
self.assertEqual(p.getH(), 5)
self.assertEqual(p.getK(), 6)
self.assertEqual(p.getL(), 7)
hkl = p.getHKL()
self.assertEquals(hkl, V3D(5,6,7))
p.setIntensity(456)
p.setSigmaIntensity(789)
self.assertEqual(p.getIntensity(), 456)
self.assertEqual(p.getSigmaIntensity(), 789)
# Finally try to remove a peak
pws.removePeak(0)
self.assertEqual(pws.getNumberPeaks(), 0)
# Create a new peak at some Q in the lab frame
qlab = V3D(1,2,3)
p = pws.createPeak(qlab, 1.54)
p.getQLabFrame()
self.assertAlmostEquals( p.getQLabFrame().X(), 1.0, 3)
# Now try to add the peak back
pws.addPeak(p)
self.assertEqual(pws.getNumberPeaks(), 1)
# Check that it is what we added to it
p = pws.getPeak(0)
self.assertAlmostEquals( p.getQLabFrame().X(), 1.0, 3)
# Peaks workspace will not be integrated by default.
self.assertTrue(not pws.hasIntegratedPeaks())
def test_peak_setQLabFrame(self):
pws = WorkspaceCreationHelper.createPeaksWorkspace(1, True)
p = pws.getPeak(0)
try:
p.setQLabFrame(V3D(1,1,1))
except Exception:
self.fail("Tried setQLabFrame with one V3D argument")
self.assertAlmostEquals( p.getQLabFrame().X(), 1.0, places=10)
self.assertAlmostEquals( p.getQLabFrame().Y(), 1.0, places=10)
self.assertAlmostEquals( p.getQLabFrame().Z(), 1.0, places=10)
try:
p.setQLabFrame(V3D(1,1,1), 1)
except Exception:
self.fail("Tried setQLabFrame with one V3D argument and a double distance")
self.assertAlmostEquals( p.getQLabFrame().X(), 1.0, places=10)
self.assertAlmostEquals( p.getQLabFrame().Y(), 1.0, places=10)
self.assertAlmostEquals( p.getQLabFrame().Z(), 1.0, places=10)
def test_interface(self):
""" Rudimentary test to get peak and get/set some values """
pws = WorkspaceCreationHelper.createPeaksWorkspace(1)
self.assertTrue(isinstance(pws, IPeaksWorkspace))
self.assertEqual(pws.getNumberPeaks(), 1)
p = pws.getPeak(0)
# Try a few IPeak get/setters. Not everything.
p.setH(234)
self.assertEqual(p.getH(), 234)
p.setHKL(5,6,7)
self.assertEqual(p.getH(), 5)
self.assertEqual(p.getK(), 6)
self.assertEqual(p.getL(), 7)
hkl = p.getHKL()
self.assertEquals(hkl, V3D(5,6,7))
p.setIntensity(456)
p.setSigmaIntensity(789)
self.assertEqual(p.getIntensity(), 456)
self.assertEqual(p.getSigmaIntensity(), 789)
# Finally try to remove a peak
pws.removePeak(0)
self.assertEqual(pws.getNumberPeaks(), 0)
# Create a new peak at some Q in the lab frame
qlab = V3D(1,2,3)
p = pws.createPeak(qlab, 1.54)
p.getQLabFrame()
self.assertAlmostEquals( p.getQLabFrame().X(), 1.0, 3)
# Now try to add the peak back
pws.addPeak(p)
self.assertEqual(pws.getNumberPeaks(), 1)
# Check that it is what we added to it
p = pws.getPeak(0)
self.assertAlmostEquals( p.getQLabFrame().X(), 1.0, 3)
# Peaks workspace will not be integrated by default.
self.assertTrue(not pws.hasIntegratedPeaks())
def test_col_rol(self):
pws = WorkspaceCreationHelper.createPeaksWorkspace(0, True)
# Incident wavevector
wavelength = 2.0 # Angstroms
k = 2 * math.pi / wavelength
ki = pws.getInstrument().getReferenceFrame().vecPointingAlongBeam() * k
# Final Wavevector
detector_id = 42 # column_id = 4, row_id = 2
kf = pws.componentInfo().position(detector_id)
kf = kf * (k / kf.norm())
# Peak
q_lab = ki - kf # inelastic convention
peak = pws.createPeak(q_lab)
pws.addPeak(peak)
col, row = pws.row(0)['Col'], pws.row(0)['Row']
self.assertAlmostEqual(col, 4)
self.assertAlmostEquals(row, 2)
def setUp(self):
if self._test_ws is None:
self.__class__._test_ws = WorkspaceCreationHelper.create2DWorkspaceWithFullInstrument(
2, 102, False) # no monitors
def test_hasMaskedBins(self):
numBins = 10
numHist=11
ws = WorkspaceCreationHelper.create2DWorkspace123WithMaskedBin(numHist, numBins, 0, 1)
self.assertTrue(ws.hasMaskedBins(0))
self.assertFalse(ws.hasMaskedBins(1))
def setUp(self):
if self._test_ws is None:
self.__class__._test_ws = WorkspaceCreationHelper.create2DWorkspaceWithFullInstrument(
2, 102, False) # no monitors
def setUp(self):
if self._test_mdws is None:
signal = 3.0
self.__class__._test_mdws = WorkspaceCreationHelper.makeFakeMDHistoWorkspace(signal, self._test_ndims) # A type of MDGeometry
def setUp(self):
if self.__class__._ws is None:
self.__class__._ws = WorkspaceCreationHelper.create2DWorkspaceWithFullInstrument(2, 1, False) # no monitors
self.__class__._ws.getSpectrum(0).clearDetectorIDs()
def setUp(self):
if self._test_mdws is None:
signal = 3.0
self.__class__._test_mdws = WorkspaceCreationHelper.makeFakeMDHistoWorkspace(signal, self._test_ndims) # A type of MDGeometry
def _createMultiSpectra(self, wkspname):
wksp = WCH.create2DWorkspaceWithFullInstrument(30, 5, False, False)
AnalysisDataService.add(wkspname, wksp)
def setUp(self):
if self.__testws is None:
self.__class__.__testws = \
WorkspaceCreationHelper.create2DWorkspaceWithFullInstrument(1,1)
def setUp(self):
if self._test_ws is None:
self.__class__._test_ws = \
WorkspaceCreationHelper.createEventWorkspace2(self._npixels, self._nbins)
