def _applyIncidentEnergyCalibration(ws, wsType, eiWS, wsNames, report, algorithmLogging): """Update incident energy and wavelength in the sample logs.""" originalEnergy = ws.getRun().getLogData('Ei').value originalWavelength = ws.getRun().getLogData('wavelength').value energy = eiWS.readY(0)[0] wavelength = UnitConversion.run('Energy', 'Wavelength', energy, 0, 0, 0, Direct, 5) if wsType == common.WS_CONTENT_DETS: calibratedWSName = wsNames.withSuffix('incident_energy_calibrated_detectors') elif wsType == common.WS_CONTENT_MONS: calibratedWSName = wsNames.withSuffix('incident_energy_calibrated_monitors') else: raise RuntimeError('Unknown workspace content type') calibratedWS = CloneWorkspace(InputWorkspace=ws, OutputWorkspace=calibratedWSName, EnableLogging=algorithmLogging) AddSampleLog(Workspace=calibratedWS, LogName='Ei', LogText=str(energy), LogType='Number', NumberType='Double', LogUnit='meV', EnableLogging=algorithmLogging) AddSampleLog(Workspace=calibratedWS, Logname='wavelength', LogText=str(wavelength), LogType='Number', NumberType='Double', LogUnit='Angstrom', EnableLogging=algorithmLogging) report.notice("Applied Ei calibration to '" + str(ws) + "'.") report.notice('Original Ei: {} new Ei: {}.'.format(originalEnergy, energy)) report.notice('Original wavelength: {} new wavelength {}.'.format(originalWavelength, wavelength)) return calibratedWS
def _applyIncidentEnergyCalibration(ws, eiWS, wsNames, report, algorithmLogging): """Update incident energy and wavelength in the sample logs.""" originalEnergy = ws.getRun().getLogData('Ei').value originalWavelength = ws.getRun().getLogData('wavelength').value energy = eiWS.readY(0)[0] wavelength = UnitConversion.run('Energy', 'Wavelength', energy, 0, 0, 0, Direct, 5) AddSampleLog(Workspace=ws, LogName='Ei', LogText=str(energy), LogType='Number', NumberType='Double', LogUnit='meV', EnableLogging=algorithmLogging) AddSampleLog(Workspace=ws, Logname='wavelength', LogText=str(wavelength), LogType='Number', NumberType='Double', LogUnit='Angstrom', EnableLogging=algorithmLogging) report.notice("Applied Ei calibration to '" + str(ws) + "'.") report.notice('Original Ei: {} new Ei: {}.'.format(originalEnergy, energy)) report.notice('Original wavelength: {} new wavelength {}.'.format( originalWavelength, wavelength)) return ws
def testDetectorNormalisation(self): data1 = HB3AAdjustSampleNorm('HB3A_data.nxs', OutputType='Detector', NormaliseBy='None') self.assertEqual(data1.getSignalArray().max(), 16) self.assertEqual(data1.getErrorSquaredArray().max(), 16) # normlise by time, data 2 seconds data2 = HB3AAdjustSampleNorm('HB3A_data.nxs', OutputType='Detector', NormaliseBy='Time') self.assertEqual(data2.getSignalArray().max(), 16/2) self.assertEqual(data2.getErrorSquaredArray().max(), 16/2**2) # normalize by monitor, about 621 counts data3 = HB3AAdjustSampleNorm('HB3A_data.nxs', OutputType='Detector', NormaliseBy='Monitor') self.assertAlmostEqual(data3.getSignalArray().max(), 16/621) self.assertAlmostEqual(data3.getErrorSquaredArray().max(), 16/621**2) # create van data van = SliceMDHisto(data1, '0,0,0', '1536,512,1') van.setSignalArray(np.full_like(van.getSignalArray(), 25)) van.setErrorSquaredArray(np.full_like(van.getSignalArray(), 25)) AddSampleLog(van, LogName='time', LogText='42', LogType='Number Series', NumberType='Double') AddSampleLog(van, LogName='monitor', LogText='420', LogType='Number Series', NumberType='Double') data1 = HB3AAdjustSampleNorm('HB3A_data.nxs', VanadiumWorkspace=van, OutputType='Detector', NormaliseBy='None') self.assertAlmostEqual(data1.getSignalArray().max(), 16/25) self.assertAlmostEqual(data1.getErrorSquaredArray().max(), (16/25)**2*(1/16+1/25)) # normlise by time, data 2 seconds data2 = HB3AAdjustSampleNorm('HB3A_data.nxs', VanadiumWorkspace=van, OutputType='Detector', NormaliseBy='Time') self.assertAlmostEqual(data2.getSignalArray().max(), 16/25*42/2) self.assertAlmostEqual(data2.getErrorSquaredArray().max(), (16/25)**2*(1/16+1/25) * (42/2)**2) # normalize by monitor, about 621 counts data3 = HB3AAdjustSampleNorm('HB3A_data.nxs', VanadiumWorkspace=van, OutputType='Detector', NormaliseBy='Monitor') self.assertAlmostEqual(data3.getSignalArray().max(), 16/25*420/621) self.assertAlmostEqual(data3.getErrorSquaredArray().max(), (16/25)**2*(1/16+1/25) * (420/621)**2)
def _addForegroundToLogs(self, ws, beamPosWS): """Add foreground start and end workspace indices to the sample logs of ws.""" hws = self._foregroundWidths() beamPosIndex = self._foregroundCentre(beamPosWS) sign = self._workspaceIndexDirection(ws) start = beamPosIndex - sign * hws[0] end = beamPosIndex + sign * hws[1] if start > end: end, start = start, end AddSampleLog(Workspace=ws, LogName=common.SampleLogs.FOREGROUND_START, LogText=str(start), LogType='Number', NumberType='Int', EnableLogging=self._subalgLogging) AddSampleLog(Workspace=ws, LogName=common.SampleLogs.FOREGROUND_CENTRE, LogText=str(beamPosIndex), logType='Number', NumberType='Int', EnableLogging=self._subalgLogging) AddSampleLog(Workspace=ws, LogName=common.SampleLogs.FOREGROUND_END, LogText=str(end), LogType='Number', NumberType='Int', EnableLogging=self._subalgLogging) return ws
def test_edge_case(self): # This is to capture the case where there are identical theta # values for multiple spectra which cause problems when # ResampleX is run with particular Xmin and Xmax causing the # output to be all zeros. # Create more real test workspace, using same properties as # HB2C_558131 data = np.ones((256, 1920)) CreateWorkspace( DataX=[0, 1], DataY=data, DataE=np.sqrt(data), UnitX='Empty', YUnitLabel='Counts', NSpec=1966080 // 4, OutputWorkspace='tmp_ws') AddSampleLog('tmp_ws', LogName='HB2C:Mot:s2.RBV', LogText='29.9774', LogType='Number Series', NumberType='Double') AddSampleLog('tmp_ws', LogName='HB2C:Mot:detz.RBV', LogText='0', LogType='Number Series', NumberType='Double') tmp_ws = mtd['tmp_ws'] for n in range(tmp_ws.getNumberHistograms()): s = tmp_ws.getSpectrum(n) for i in range(2): for j in range(2): s.addDetectorID(int(n * 2 % 512 + n // (512 / 2) * 512 * 2 + j + i * 512)) LoadInstrument('tmp_ws', InstrumentName='WAND', RewriteSpectraMap=False) out = WANDPowderReduction('tmp_ws', Target='Theta', XMin=29, XMax=31, NumberBins=10, NormaliseBy='None') np.testing.assert_allclose(out.readY(0), [0, 0, 0, 0, 269.068237, 486.311606, 618.125152, 720.37274, 811.141863, 821.032586], rtol=5e-4) tmp_ws.delete() out.delete()
def setUp(self): ws = CreateWorkspace(DataX='1,11,111,1,11,111', DataY='2,22,22,22', DataE='1,5,5,5', UnitX="TOF", NSpec=2) AddSampleLog(ws, LogName='wavelength', LogText='6.5', LogType='Number Series') AddSampleLog(ws, LogName='wavelength_spread', LogText='0.1', LogType='Number Series')
def _add_all_sample_logs(self, ws): """ add all sample logs to a workspace :param ws: workspace where sample logs should be added """ AddSampleLog(ws, "proposal_number", str(self.prop_num)) AddSampleLog(ws, "proposal_title", self.prop_title) AddSampleLog(ws, "experiment_team", self.exp_team) AddSampleLog(ws, "temperature", str(self.temperature), LogUnit="F") AddSampleLog(ws, "Ei", str(self.Ei), LogUnit="meV")
def test_nasty_log(self): AddSampleLog(self.ws1, 'chopper_speed', '14000.0', 'String') AddSampleLog(self.ws2, 'chopper_speed', '1400q', 'String') wslist = [self.ws1, self.ws2] alg_test = run_algorithm("CompareSampleLogs", InputWorkspaces=wslist, SampleLogs='chopper_speed', Tolerance=10.0) self.assertTrue(alg_test.isExecuted()) result = alg_test.getProperty('Result').value self.assertEqual('chopper_speed', result)
def runTest(self): # create van data van = LoadWANDSCD('HB2C_7000.nxs.h5') van.setSignalArray(np.full_like(van.getSignalArray(), 25)) van.setErrorSquaredArray(np.full_like(van.getSignalArray(), 25)) AddSampleLog(van, LogName='duration', LogText='42', LogType='Number Series', NumberType='Double') AddSampleLog(van, LogName='monitor_count', LogText='420', LogType='Number Series', NumberType='Double') # NOTE: all reference values are copied from terminal after confirm the code is correct LoadWANDTest_ws = LoadWANDSCD( Filename='HB2C_7000.nxs.h5,HB2C_7001.nxs.h5', VanadiumWorkspace=van, NormalizedBy='Monitor') ref_val = 0.00012953253733973653 self.assertAlmostEqual(LoadWANDTest_ws.getSignalArray().max(), ref_val, 5) self.assertAlmostEqual(LoadWANDTest_ws.getErrorSquaredArray().max(), 0.0, 5) # LoadWANDTest_ws = LoadWANDSCD( Filename='HB2C_7000.nxs.h5,HB2C_7001.nxs.h5', VanadiumWorkspace=van, NormalizedBy='Counts') ref_val = 0.0112 self.assertAlmostEqual(LoadWANDTest_ws.getSignalArray().max(), ref_val, 5) ref_err = 2.29376e-05 self.assertAlmostEqual(LoadWANDTest_ws.getErrorSquaredArray().max(), ref_err, 5) # LoadWANDTest_ws = LoadWANDSCD( Filename='HB2C_7000.nxs.h5,HB2C_7001.nxs.h5', VanadiumWorkspace=van, NormalizedBy='Time') ref_val = 0.29363296439511044 self.assertAlmostEqual(LoadWANDTest_ws.getSignalArray().max(), ref_val, 5) ref_err = 0.0157660 self.assertAlmostEqual(LoadWANDTest_ws.getErrorSquaredArray().max(), ref_err, 5) LoadWANDTest_ws.delete() van.delete()
def createTestWorkspace(self, run=23456): """ Create a workspace for testing against with ideal log values """ from mantid.simpleapi import CreateWorkspace from mantid.simpleapi import AddSampleLog from time import gmtime, strftime,mktime import numpy as np # Create a matrix workspace x = np.array([1.,2.,3.,4.]) y = np.array([1.,2.,3.]) e = np.sqrt(np.array([1.,2.,3.])) wksp = CreateWorkspace(DataX=x, DataY=y,DataE=e,NSpec=1,UnitX='TOF') # Add run_start tmptime = strftime("%Y-%m-%d %H:%M:%S", gmtime(mktime(gmtime()))) AddSampleLog(Workspace=wksp,LogName='run_start',LogText=str(tmptime)) tsp_a=kernel.FloatTimeSeriesProperty("proton_charge") tsp_b=kernel.FloatTimeSeriesProperty("SensorA") for i in arange(25): tmptime = strftime("%Y-%m-%d %H:%M:%S", gmtime(mktime(gmtime())+i)) if run == 23456: shift = 0 else: shift = int(run) tsp_a.addValue(tmptime, 1.0*i*i + shift) tsp_b.addValue(tmptime, 1.234*(i+1)) wksp.mutableRun()['run_number']=str(run) wksp.mutableRun()['duration']=342.3 wksp.mutableRun()['SensorA'] = tsp_b wksp.mutableRun()['proton_charge']=tsp_a return wksp
def setUpClass(cls): x = np.linspace(0, 99, 100) y = x * 1 e = y * 0 + 2 cls.m_workspace = wrap_workspace( CreateWorkspace(x, y, e, OutputWorkspace="m_ws"), 'm_ws') sim_workspace = CreateSimulationWorkspace(Instrument='MAR', BinParams=[-10, 1, 10], UnitX='DeltaE', OutputWorkspace='ws1') AddSampleLog(sim_workspace, LogName='Ei', LogText='3.', LogType='Number') cls.px_workspace = ConvertToMD(InputWorkspace=sim_workspace, OutputWorkspace="ws1", QDimensions='|Q|', dEAnalysisMode='Direct', MinValues='-10,0,0', MaxValues='10,6,500', SplitInto='50,50') cls.px_workspace_clone = CloneWorkspace( InputWorkspace=cls.px_workspace, OutputWorkspace='ws2', StoreInADS=False) cls.px_workspace = wrap_workspace(cls.px_workspace, 'ws1') cls.px_workspace_clone = wrap_workspace(cls.px_workspace_clone, 'ws2')
def test_multiple_histograms(self): energyBins = np.arange(-7., 7., 0.13) qs = np.array([1.1, 1.3, 1.5, 1.7]) EFixed = 8. Ys = np.ones(3 * (len(energyBins) - 1)) Es = Ys verticalAxis = [str(q) for q in qs] ws = CreateWorkspace(energyBins, Ys, Es, NSpec=3, UnitX='DeltaE', VerticalAxisUnit='MomentumTransfer', VerticalAxisValues=verticalAxis, StoreInADS=False) LoadInstrument(ws, InstrumentName='IN4', RewriteSpectraMap=False, StoreInADS=False) AddSampleLog(ws, LogName='Ei', LogText=str(EFixed), LogType='Number', LogUnit='meV', StoreInADS=False) dos = ComputeIncoherentDOS(ws, EnergyBinning='Emin, Emax', StoreInADS=False) self.assertEqual(dos.getNumberHistograms(), 1) self.assertEqual(dos.getAxis(0).getUnit().unitID(), 'DeltaE') dos_Xs = dos.readX(0) self.assertEqual(len(dos_Xs), len(energyBins)) dos_Ys = dos.readY(0) dos_Es = dos.readE(0) g1 = self.compute(qs[0:2], energyBins) g2 = self.compute(qs[1:3], energyBins) g3 = self.compute(qs[2:4], energyBins) g = (g1 + g2 + g3) / 3 gE = np.sqrt(g1**2 + g2**2 + g3**2) / 3 np.testing.assert_equal(dos_Xs, energyBins) for i in range(len(dos_Ys)): self.assertAlmostEquals(dos_Ys[i], g[i]) self.assertAlmostEquals(dos_Es[i], gE[i])
def _sumForegroundInLambda(self, ws): """Sum the foreground region into a single histogram.""" foreground = self._foregroundIndices(ws) sumIndices = [i for i in range(foreground[0], foreground[2] + 1)] beamPosIndex = foreground[1] foregroundWSName = self._names.withSuffix('foreground_grouped') foregroundWS = ExtractSingleSpectrum(InputWorkspace=ws, OutputWorkspace=foregroundWSName, WorkspaceIndex=beamPosIndex, EnableLogging=self._subalgLogging) maxIndex = ws.getNumberHistograms() - 1 foregroundYs = foregroundWS.dataY(0) foregroundEs = foregroundWS.dataE(0) numpy.square(foregroundEs, out=foregroundEs) for i in sumIndices: if i == beamPosIndex: continue if i < 0 or i > maxIndex: self.log().warning( 'Foreground partially out of the workspace.') ys = ws.readY(i) foregroundYs += ys es = ws.readE(i) foregroundEs += es**2 numpy.sqrt(foregroundEs, out=foregroundEs) self._cleanup.cleanup(ws) AddSampleLog(Workspace=foregroundWS, LogName=common.SampleLogs.SUM_TYPE, LogText=SumType.IN_LAMBDA, LogType='String', EnableLogging=self._subalgLogging) ConvertToDistribution(Workspace=foregroundWS, EnableLogging=self._subalgLogging) return foregroundWS
def setUp(self): input_ws = CreateSampleWorkspace( Function="User Defined", UserDefinedFunction="name=LinearBackground, " + "A0=0.3;name=Gaussian, PeakCentre=5, Height=10, Sigma=0.3", NumBanks=2, BankPixelWidth=1, XMin=0, XMax=10, BinWidth=0.1, BankDistanceFromSample=4.0) self._input_ws = input_ws self._table = FindEPP(input_ws, OutputWorkspace="table") AddSampleLog(self._input_ws, LogName='wavelength', LogText='4.0', LogType='Number', LogUnit='Angstrom') for i in range(input_ws.getNumberHistograms()): y = input_ws.dataY(i) y.fill(0.) y[51] = 100. e = input_ws.dataE(i) e.fill(0.) e[51] = 10.
def setUpClass(cls): cls.sim_scattering_data = np.arange(0, 1.5, 0.002).reshape(30, 25).transpose() cls.scattering_rotated = np.rot90(cls.sim_scattering_data, k=3) cls.scattering_rotated = np.flipud(cls.scattering_rotated) cls.e_axis = Axis('DeltaE', -10, 15, 1) cls.q_axis = Axis('|Q|', 0.1, 3.1, 0.1) cls.q_axis_degrees = Axis('Degrees', 3, 33, 1) cls.test_ws = CreateSampleWorkspace(OutputWorkspace='test_ws', NumBanks=1, BankPixelWidth=5, XMin=0.1, XMax=3.1, BinWidth=0.1, XUnit='DeltaE') for i in range(cls.test_ws.raw_ws.getNumberHistograms()): cls.test_ws.raw_ws.setY(i, cls.sim_scattering_data[i]) AddSampleLog(workspace=cls.test_ws.raw_ws, LogName='Ei', LogText='3.', LogType='Number', StoreInADS=False) cls.test_ws.e_mode = 'Direct' cls.test_ws.e_fixed = 3
def _addSumTypeToLogs(self, ws, sumType): """Add a sum type entry to sample logs.""" AddSampleLog(Workspace=ws, LogName=common.SampleLogs.SUM_TYPE, LogText=sumType, LogType='String', EnableLogging=self._subalgLogging)
def createTestWorkspace(self): """ Create a workspace for testing against with ideal log values """ from mantid.simpleapi import CreateWorkspace from mantid.simpleapi import AddSampleLog from time import gmtime, strftime, mktime # Create a matrix workspace x = np.array([1., 2., 3., 4.]) y = np.array([1., 2., 3.]) e = np.sqrt(np.array([1., 2., 3.])) wksp = CreateWorkspace(DataX=x, DataY=y, DataE=e, NSpec=1, UnitX='TOF') # Add run_start tmptime = strftime("%Y-%m-%d %H:%M:%S", gmtime(mktime(gmtime()))) AddSampleLog(Workspace=wksp, LogName='run_start', LogText=str(tmptime)) tsp_a = kernel.FloatTimeSeriesProperty("SensorA") tsp_b = kernel.FloatTimeSeriesProperty("SensorB") tsp_c = kernel.FloatTimeSeriesProperty("SensorC") for i in np.arange(25): tmptime = strftime("%Y-%m-%d %H:%M:%S", gmtime(mktime(gmtime()) + i)) tsp_a.addValue(tmptime, 1.0 * i * i) tsp_b.addValue(tmptime, 2.0 * i * i) tsp_c.addValue(tmptime, 3.0 * i * i) wksp.mutableRun()['SensorA'] = tsp_a wksp.mutableRun()['SensorB'] = tsp_b wksp.mutableRun()['SensorC'] = tsp_c return wksp
def test_plotDOS_PlotMultiple(self): ws = CreateSampleWorkspace(NumBanks=1, XUnit='DeltaE', XMin=-12., XMax=12., BinWidth=0.2, StoreInADS=False) MoveInstrumentComponent(ws, 'bank1', X=-0.5, StoreInADS=False) ws = ConvertSpectrumAxis(ws, 'Theta', 'Direct', 14., StoreInADS=False) SetInstrumentParameter(ws, ParameterName='deltaE-mode', Value='direct', StoreInADS=False) AddSampleLog(ws, LogName='Ei', LogText=str(14.), LogType='Number', LogUnit='meV', StoreInADS=False) stw = ComputeIncoherentDOS(ws) kwargs = {'workspaces': [stw, 'stw']} figure, axes = testhelpers.assertRaisesNothing(self, directtools.plotDOS, **kwargs) self.assertEqual(axes.get_xlabel(), 'Energy transfer ($meV$)') self.assertEqual(axes.get_ylabel(), '$g(E)$')
def setUp(self): input_ws = CreateSampleWorkspace(Function="User Defined", UserDefinedFunction="name=LinearBackground, A0=0.3;name=Gaussian, \ PeakCentre=5, Height=10, Sigma=0.3", NumBanks=2, BankPixelWidth=1, XMin=0, XMax=10, BinWidth=0.1, BankDistanceFromSample=4.0) self._input_ws = input_ws self._table = FindEPP(input_ws, OutputWorkspace="table") AddSampleLog(self._input_ws, LogName='wavelength', LogText='4.0', LogType='Number', LogUnit='Angstrom')
def test_HFIRCalculateGoniometer_HB3A_phi(self): omega = np.deg2rad(42) chi = np.deg2rad(-3) phi = np.deg2rad(23) R1 = np.array([ [np.cos(omega), 0, -np.sin(omega)], # omega 0,1,0,-1 [0, 1, 0], [np.sin(omega), 0, np.cos(omega)] ]) R2 = np.array([ [np.cos(chi), np.sin(chi), 0], # chi 0,0,1,-1 [-np.sin(chi), np.cos(chi), 0], [0, 0, 1] ]) R3 = np.array([ [np.cos(phi), 0, -np.sin(phi)], # phi 0,1,0,-1 [0, 1, 0], [np.sin(phi), 0, np.cos(phi)] ]) R = np.dot(np.dot(R1, R2), R3) wl = 1.54 k = 2 * np.pi / wl theta = np.deg2rad(47) phi = np.deg2rad(13) q_lab = np.array([ -np.sin(theta) * np.cos(phi), -np.sin(theta) * np.sin(phi), 1 - np.cos(theta) ]) * k q_sample = np.dot(np.linalg.inv(R), q_lab) peaks = CreatePeaksWorkspace(OutputType="LeanElasticPeak", NumberOfPeaks=0) AddSampleLog(peaks, "Wavelength", str(wl), "Number") SetGoniometer(peaks, Axis0='42,0,1,0,-1', Axis1='-3,0,0,1,-1') # don't set phi p = peaks.createPeakQSample(q_sample) peaks.addPeak(p) HFIRCalculateGoniometer(peaks, OverrideProperty=True, InnerGoniometer=True) g = Goniometer() g.setR(peaks.getPeak(0).getGoniometerMatrix()) YZY = g.getEulerAngles('YZY') self.assertAlmostEqual(YZY[0], -42, delta=1e-10) # omega self.assertAlmostEqual(YZY[1], 3, delta=1e-10) # chi self.assertAlmostEqual(YZY[2], -23, delta=1e-1) # phi self.assertAlmostEqual(peaks.getPeak(0).getWavelength(), 1.54, delta=1e-10)
def test_invalid_epp(self): AddSampleLog(self._input_ws, LogName='EPP', LogText=str(0), LogType='Number') OutputWorkspaceName = "outputws" self.assertRaises(RuntimeError, TOFTOFConvertTofToDeltaE, InputWorkspace=self._input_ws, OutputWorkspace=OutputWorkspaceName)
def unitySTwoThetaWSingleHistogram(self, energyBins, qs): EFixed = 8. Ys = np.ones(len(energyBins) - 1) Es = Ys verticalAxis = [str(q) for q in qs] ws = CreateWorkspace(energyBins, Ys, Es, UnitX='DeltaE', VerticalAxisUnit='Degrees', VerticalAxisValues=verticalAxis, StoreInADS=False) LoadInstrument(ws, InstrumentName='IN4', RewriteSpectraMap=False, StoreInADS=False) AddSampleLog(ws, LogName='Ei', LogText=str(EFixed), LogType='Number', LogUnit='meV', StoreInADS=False) return ws
def load_instrument(raw_data_ws_name, idf_name, two_theta, cal_shift_x, cal_shift_y): """ Set up parameters to workspace and load instrument """ # instrument position AddSampleLog(Workspace=raw_data_ws_name, LogName='cal::2theta', LogText='{}'.format(-two_theta), LogType='Number Series', LogUnit='degree', NumberType='Double') # calibration information AddSampleLog(Workspace=raw_data_ws_name, LogName='cal::arm', LogText='0.0', LogType='Number Series', LogUnit='meter', NumberType='Double') AddSampleLog(Workspace=raw_data_ws_name, LogName='cal::deltax', LogText='{}'.format(cal_shift_x), LogType='Number Series', LogUnit='meter', NumberType='Double') AddSampleLog(Workspace=raw_data_ws_name, LogName='cal::deltay', LogText='{}'.format(-cal_shift_y), LogType='Number Series', LogUnit='meter', NumberType='Double') AddSampleLog(Workspace=raw_data_ws_name, LogName='cal::flip', LogText='0.0', LogType='Number Series', LogUnit='degree', NumberType='Double') AddSampleLog(Workspace=raw_data_ws_name, LogName='cal::roty', LogText='{}'.format(-two_theta), LogType='Number Series', LogUnit='degree', NumberType='Double') AddSampleLog(Workspace=raw_data_ws_name, LogName='cal::spin', LogText='90.0', LogType='Number Series', LogUnit='degree', NumberType='Double') # Load instrument LoadInstrument(Workspace=raw_data_ws_name, Filename=idf_name, RewriteSpectraMap=True) # print output print_position(mtd[raw_data_ws_name]) return mtd[raw_data_ws_name]
def _create_workspace(self, run_number, prefix='', suffix=''): name = prefix + str(run_number) + suffix ws = CreateSampleWorkspace(WorkspaceType='Histogram', NumBanks=1, NumMonitors=2, BankPixelWidth=2, XMin=200, OutputWorkspace=name) AddSampleLog(Workspace=ws, LogName='run_number', LogText=str(run_number))
def _prepare_sans2d_empty_ws(): workspace = load_empty_instrument("SANS2D") # Taken from SANS2D00028784 AddSampleLog(Workspace=workspace, LogName="Front_Det_X", LogText="-859.968") AddSampleLog(Workspace=workspace, LogName="Front_Det_Z", LogText="5001.97") AddSampleLog(Workspace=workspace, LogName="Front_Det_ROT", LogText="-9.02552") AddSampleLog(Workspace=workspace, LogName="Rear_Det_X", LogText="100.048") AddSampleLog(Workspace=workspace, LogName="Rear_Det_Z", LogText="11999.0") return workspace
def sum_regular_runs(workspace_names): """ Sum runs with single workspace data. @param workspace_names List of names of input workspaces @return List of names of workspaces """ from mantid.simpleapi import (MergeRuns, Scale, AddSampleLog, DeleteWorkspace) # Use the first workspace name as the result of summation summed_detector_ws_name = workspace_names[0] summed_monitor_ws_name = workspace_names[0] + '_mon' # Get a list of the run numbers for the original data run_numbers = ','.join( [str(mtd[ws_name].getRunNumber()) for ws_name in workspace_names]) # Generate lists of the detector and monitor workspaces detector_workspaces = ','.join(workspace_names) monitor_workspaces = ','.join( [ws_name + '_mon' for ws_name in workspace_names]) # Merge the raw workspaces MergeRuns(InputWorkspaces=detector_workspaces, OutputWorkspace=summed_detector_ws_name) MergeRuns(InputWorkspaces=monitor_workspaces, OutputWorkspace=summed_monitor_ws_name) # Delete old workspaces for idx in range(1, len(workspace_names)): DeleteWorkspace(workspace_names[idx]) DeleteWorkspace(workspace_names[idx] + '_mon') # Derive the scale factor based on number of merged workspaces scale_factor = 1.0 / len(workspace_names) logger.information('Scale factor for summed workspaces: %f' % scale_factor) # Scale the new detector and monitor workspaces Scale(InputWorkspace=summed_detector_ws_name, OutputWorkspace=summed_detector_ws_name, Factor=scale_factor) Scale(InputWorkspace=summed_monitor_ws_name, OutputWorkspace=summed_monitor_ws_name, Factor=scale_factor) # Add the list of run numbers to the result workspace as a sample log AddSampleLog(Workspace=summed_detector_ws_name, LogName='multi_run_numbers', LogType='String', LogText=run_numbers) # Only have the one workspace now return [summed_detector_ws_name]
def PyExec(self): filename = self.getProperty("Filename").value wavelength = self.getProperty("wavelength").value outWS = self.getPropertyValue("OutputWorkspace") LoadEventNexus(Filename=filename, OutputWorkspace=outWS, LoadMonitors=True) Integration(InputWorkspace=outWS, OutputWorkspace=outWS) if self.getProperty("ApplyMask").value: MaskBTP(outWS, Bank='8', Tube='449-480') MaskBTP(outWS, Pixel='1,2,511,512') mtd[outWS].getAxis(0).setUnit("Wavelength") w = [wavelength - 0.001, wavelength + 0.001] for idx in range(mtd[outWS].getNumberHistograms()): mtd[outWS].setX(idx, w) SetGoniometer(outWS, Axis0="HB2C:Mot:s1,0,1,0,1") AddSampleLog(outWS, LogName="gd_prtn_chrg", LogType='Number', NumberType='Double', LogText=str(mtd[outWS + '_monitors'].getNumberEvents())) DeleteWorkspace(outWS + '_monitors') AddSampleLog(outWS, LogName="Wavelength", LogType='Number', NumberType='Double', LogText=str(wavelength)) AddSampleLog(outWS, LogName="Ei", LogType='Number', NumberType='Double', LogText=str( UnitConversion.run('Wavelength', 'Energy', wavelength, 0, 0, 0, Elastic, 0))) self.setProperty('OutputWorkspace', outWS)
def test_log_value_combo_box_contains_sample_logs(self): ws1 = CreateSampleWorkspace() ws2 = CreateSampleWorkspace() workspaces = [ws1, ws2] for i, ws in enumerate(workspaces): AddSampleLog(Workspace=ws.name(), LogName="Test", LogText=str(i)) ssd = SpectraSelectionDialog(workspaces, advanced=True) self.assertNotEqual( ssd._ui.advanced_options_widget.ui.log_value_combo_box.findText( "Test"), -1)
def _create_workspaces(self): cal=CreateSampleWorkspace(NumBanks=1,BinWidth=20000,PixelSpacing=0.1,BankPixelWidth=100) RotateInstrumentComponent(cal, ComponentName='bank1', X=1, Y=0.5, Z=2, Angle=35) MoveInstrumentComponent(cal, ComponentName='bank1', X=1, Y=1, Z=5) bkg=CloneWorkspace(cal) data=CloneWorkspace(cal) AddSampleLog(cal, LogName="gd_prtn_chrg", LogType='Number', NumberType='Double', LogText='200') AddSampleLog(bkg, LogName="gd_prtn_chrg", LogType='Number', NumberType='Double', LogText='50') AddSampleLog(data, LogName="gd_prtn_chrg", LogType='Number', NumberType='Double', LogText='100') AddSampleLog(cal, LogName="duration", LogType='Number', NumberType='Double', LogText='20') AddSampleLog(bkg, LogName="duration", LogType='Number', NumberType='Double', LogText='5') AddSampleLog(data, LogName="duration", LogType='Number', NumberType='Double', LogText='10') def get_cal_counts(n): if n < 5000: return 0.9 else: return 1.0 def get_bkg_counts(n): return 1.5*get_cal_counts(n) def get_data_counts(n,twoTheta): tt1=30 tt2=45 return get_bkg_counts(n)+10*np.exp(-(twoTheta-tt1)**2/1)+20*np.exp(-(twoTheta-tt2)**2/0.2) for i in range(cal.getNumberHistograms()): cal.setY(i, [get_cal_counts(i)*2.0]) bkg.setY(i, [get_bkg_counts(i)/2.0]) twoTheta=data.getInstrument().getDetector(i+10000).getTwoTheta(V3D(0,0,0),V3D(0,0,1))*180/np.pi data.setY(i, [get_data_counts(i,twoTheta)]) return data, cal, bkg
def _create_event_workspace(self, run_number, prefix='', includeMonitors=True): name = prefix + str(run_number) CreateSampleWorkspace(WorkspaceType='Event', NumBanks=1, NumMonitors=3, BankPixelWidth=2, XMin=200, OutputWorkspace=name) if includeMonitors: CropWorkspace(InputWorkspace=name, StartWorkspaceIndex=0, EndWorkspaceIndex=2, OutputWorkspace=name + '_monitors') Rebin(InputWorkspace=name + '_monitors', Params='0,200,20000', OutputWorkspace=name + '_monitors', PreserveEvents=False) CropWorkspace(InputWorkspace=name, StartWorkspaceIndex=3, EndWorkspaceIndex=4, OutputWorkspace=name) AddSampleLog(Workspace=name, LogName='run_number', LogText=str(run_number)) AddTimeSeriesLog(Workspace=name, Name="proton_charge", Time="2010-01-01T00:00:00", Value=100) AddTimeSeriesLog(Workspace=name, Name="proton_charge", Time="2010-01-01T00:10:00", Value=100) AddTimeSeriesLog(Workspace=name, Name="proton_charge", Time="2010-01-01T00:20:00", Value=80) AddTimeSeriesLog(Workspace=name, Name="proton_charge", Time="2010-01-01T00:30:00", Value=80) AddTimeSeriesLog(Workspace=name, Name="proton_charge", Time="2010-01-01T00:40:00", Value=15) AddTimeSeriesLog(Workspace=name, Name="proton_charge", Time="2010-01-01T00:50:00", Value=100)