def convertToHKL(ws, OutputWorkspace='__md_hkl', norm=None, UB=None, Extents=[-10, 10, -10, 10, -10, 10], Bins=[101, 101, 101], Append=False): """Output MDEventWorkspace in HKL """ SetUB(ws, UB=UB) ConvertToMD(ws, QDimensions='Q3D', QConversionScales='HKL', dEAnalysisMode='Elastic', Q3DFrames='HKL', OutputWorkspace='__temp') AlignedDim0 = "{},{},{},{}".format(mtd['__temp'].getDimension(0).name, Extents[0], Extents[1], int(Bins[0])) AlignedDim1 = "{},{},{},{}".format(mtd['__temp'].getDimension(1).name, Extents[2], Extents[3], int(Bins[1])) AlignedDim2 = "{},{},{},{}".format(mtd['__temp'].getDimension(2).name, Extents[4], Extents[5], int(Bins[2])) BinMD(InputWorkspace='__temp', TemporaryDataWorkspace=OutputWorkspace if Append and mtd.doesExist(OutputWorkspace) else None, OutputWorkspace=OutputWorkspace, AlignedDim0=AlignedDim0, AlignedDim1=AlignedDim1, AlignedDim2=AlignedDim2) DeleteWorkspace('__temp') if norm is not None: SetUB(norm, UB=UB) ConvertToMD(norm, QDimensions='Q3D', QConversionScales='HKL', dEAnalysisMode='Elastic', Q3DFrames='HKL', OutputWorkspace='__temp_norm') BinMD(InputWorkspace='__temp_norm', TemporaryDataWorkspace=str(OutputWorkspace) + '_norm' if Append and mtd.doesExist(str(OutputWorkspace) + '_norm') else None, OutputWorkspace=str(OutputWorkspace) + '_norm', AlignedDim0=AlignedDim0, AlignedDim1=AlignedDim1, AlignedDim2=AlignedDim2) DeleteWorkspace('__temp_norm') return OutputWorkspace
def test_qtohkl_corelli(self): Load(Filename='CORELLI_29782.nxs', OutputWorkspace='data') SetGoniometer(Workspace='data', Axis0='BL9:Mot:Sample:Axis1,0,1,0,1') LoadIsawUB(InputWorkspace='data', Filename='SingleCrystalDiffuseReduction_UB.mat') ConvertToMD(InputWorkspace='data', QDimensions='Q3D', dEAnalysisMode='Elastic', Q3DFrames='HKL', QConversionScales='HKL', OutputWorkspace='HKL', Uproj='1,1,0', Vproj='1,-1,0', Wproj='0,0,1', MinValues='-20,-20,-20', MaxValues='20,20,20') hkl_binned = BinMD('HKL', AlignedDim0='[H,H,0],-10.05,10.05,201', AlignedDim1='[H,-H,0],-10.05,10.05,201', AlignedDim2='[0,0,L],-1.05,1.05,21') ConvertToMD(InputWorkspace='data', QDimensions='Q3D', dEAnalysisMode='Elastic', Q3DFrames='Q_sample', OutputWorkspace='q_sample', MinValues='-20,-20,-20', MaxValues='20,20,20') hkl = ConvertQtoHKLMDHisto( InputWorkspace=mtd["q_sample"], Uproj="1,1,0", Vproj="1,-1,0", Wproj="0,0,1", Extents="-10.05,10.05,-10.05,10.05,-1.05,1.05", Bins="201,201,21") for i in range(hkl.getNumDims()): self.assertEqual( hkl_binned.getDimension(i).name, hkl.getDimension(i).name) orig_sig = hkl_binned.getSignalArray() new_sig = hkl.getSignalArray() np.testing.assert_allclose(np.asarray(new_sig), np.asarray(orig_sig), rtol=1.0e-5, atol=3)
def example_plots(): #create slices and cuts w = Load( Filename= '/SNS/HYS/IPTS-14189/shared/autoreduce/4pixel/HYS_102102_4pixel_spe.nxs' ) SetUB(w, 4.53, 4.53, 11.2, 90, 90, 90, "1,0,0", "0,0,1") mde = ConvertToMD(w, QDimensions='Q3D') sl1d = CutMD(InputWorkspace=mde, P1Bin='-5,5', P2Bin='-5,5', P3Bin='2,4', P4Bin='-10,0.5,15', NoPix=True) sl2d = CutMD(InputWorkspace=mde, P1Bin='-5,5', P2Bin='-5,5', P3Bin='-5,0.1,5', P4Bin='-10,1,15', NoPix=True) #2 subplots per page fig, ax = plt.subplots(2, 1) Plot1DMD(ax[0], sl1d, NumEvNorm=True, fmt='ro') ax[0].set_ylabel("Int(a.u.)") pcm = Plot2DMD(ax[1], sl2d, NumEvNorm=True) fig.colorbar(pcm, ax=ax[1]) #save to png plt.tight_layout(1.08) fig.savefig('/tmp/test.png')
def prepare_background(input_md, reference_sample_mde, background_md: str): """Prepare background MDEventWorkspace from reduced sample Matrix This is the previous solution to merge all the ExperimentInfo """ dgs_data = CloneWorkspace(input_md) data_MDE = mtd[reference_sample_mde] if mtd.doesExist('background_MDE'): DeleteWorkspace('background_MDE') for i in range(data_MDE.getNumExperimentInfo()): phi, chi, omega = data_MDE.getExperimentInfo( i).run().getGoniometer().getEulerAngles('YZY') AddSampleLogMultiple(Workspace=dgs_data, LogNames='phi, chi, omega', LogValues='{},{},{}'.format(phi, chi, omega)) SetGoniometer(Workspace=dgs_data, Goniometers='Universal') ConvertToMD(InputWorkspace=dgs_data, QDimensions='Q3D', dEAnalysisMode='Direct', Q3DFrames="Q_sample", MinValues='-11,-11,-11,-25', MaxValues='11,11,11,49', PreprocDetectorsWS='-', OverwriteExisting=False, OutputWorkspace=background_md)
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 _calcQEproj(self, input_workspace, emode, axis1, axis2): """ Carries out either the Q-E or E-Q projections """ # For indirect geometry and large datafiles (likely to be using a 1-to-1 mapping use ConvertToMD('|Q|') numSpectra = input_workspace.getNumberHistograms() if emode == 'Indirect' or numSpectra > 1000: retval = ConvertToMD(InputWorkspace=input_workspace, QDimensions=MOD_Q_LABEL, PreprocDetectorsWS='-', dEAnalysisMode=emode, StoreInADS=False) if axis1 == DELTA_E_LABEL and axis2 == MOD_Q_LABEL: retval = self._flip_axes(retval) # Otherwise first run SofQW3 to rebin it in |Q| properly before calling ConvertToMD with CopyToMD else: limits = self.getProperty('Limits').value limits = ','.join([str(limits[i]) for i in [0, 2, 1]]) retval = SofQW3(InputWorkspace=input_workspace, QAxisBinning=limits, Emode=emode, StoreInADS=False) retval = ConvertToMD(InputWorkspace=retval, QDimensions='CopyToMD', PreprocDetectorsWS='-', dEAnalysisMode=emode, StoreInADS=False) if axis1 == MOD_Q_LABEL: retval = self._flip_axes(retval) return retval
def convertToQSample(ws, OutputWorkspace='__md_q_sample'): """Output MDEventWorkspace in Q Sample """ ConvertToMD(ws, QDimensions='Q3D', dEAnalysisMode='Elastic', Q3DFrames='Q_sample', MinValues='-10,-1,-10', MaxValues='10,1,10', OutputWorkspace=OutputWorkspace) return OutputWorkspace
def _calcThetaEproj(self, input_workspace, emode, axis1, axis2): """ Carries out either the 2Theta-E or E-2Theta projections """ retval = ConvertSpectrumAxis(InputWorkspace=input_workspace, Target='Theta') # Work-around for a bug in ConvertToMD. wsdet = self._getDetWS(input_workspace) if emode == 'Indirect' else '-' retval = ConvertToMD(InputWorkspace=retval, QDimensions='CopyToMD', PreprocDetectorsWS=wsdet, dEAnalysisMode=emode, StoreInADS=False) if emode == 'Indirect': DeleteWorkspace(wsdet) if axis1 == THETA_LABEL: retval = self._flip_axes(retval) return retval
def setUpClass(cls): # create (non-zero) test data sim_workspace = CreateSimulationWorkspace(Instrument='MAR', BinParams=[-10, 1, 10], UnitX='DeltaE', OutputWorkspace='simws') AddSampleLog(sim_workspace, LogName='Ei', LogText='3.', LogType='Number') cls.workspace = ConvertToMD(InputWorkspace=sim_workspace, OutputWorkspace="convert_ws", QDimensions='|Q|', dEAnalysisMode='Direct', MinValues='-10,0,0', MaxValues='10,6,500', SplitInto='50,50') cls.workspace = PixelWorkspace(cls.workspace, 'convert_ws')
def prepare_single_exp_info_background(input_md_name, output_md_name, target_qframe='Q_lab'): """Prepare a background MDE containing only 1 ExperimentInfo :param self: :return: """ if target_qframe not in ['Q_sample', 'Q_lab']: raise ValueError( f'QFrame with name {target_qframe} is not recognized.') # Create background workspace in Q lab ConvertToMD(InputWorkspace=input_md_name, QDimensions='Q3D', Q3DFrames=target_qframe, OutputWorkspace=output_md_name, MinValues='-11,-11,-11,-25', MaxValues='11,11,11,49')
def example_pdf(): #create slices and cuts w = Load( Filename= '/SNS/HYS/IPTS-14189/shared/autoreduce/4pixel/HYS_102102_4pixel_spe.nxs' ) SetUB(w, 4.53, 4.53, 11.2, 90, 90, 90, "1,0,0", "0,0,1") mde = ConvertToMD(w, QDimensions='Q3D') with PdfPages('/tmp/multipage_pdf.pdf') as pdf: for i in range(4): llims = str(i - 0.5) + ',' + str(i + 0.5) sl1d = CutMD(InputWorkspace=mde, P1Bin='-5,5', P2Bin='-5,5', P3Bin=llims, P4Bin='-10,0.5,15', NoPix=True) fig, ax = plt.subplots() Plot1DMD(ax, sl1d, NumEvNorm=True, fmt='ko') ax.set_title("L=[" + llims + "]") pdf.savefig(fig) plt.close('all')
def convertToHKL(ws, OutputWorkspace='__md_hkl', UB=None, Append=False, scale=None, BinningDim0='-10.05,10.05,201', BinningDim1='-10.05,10.05,201', BinningDim2='-10.05,10.05,201', Uproj=(1, 0, 0), Vproj=(0, 1, 0), Wproj=(0, 0, 1)): """Output MDHistoWorkspace in HKL """ SetUB(ws, UB=UB) ConvertToMD(ws, QDimensions='Q3D', QConversionScales='HKL', dEAnalysisMode='Elastic', Q3DFrames='HKL', OutputWorkspace='__temp', Uproj=Uproj, Vproj=Vproj, Wproj=Wproj) if scale is not None: mtd['__temp'] *= scale BinMD(InputWorkspace='__temp', TemporaryDataWorkspace=OutputWorkspace if Append and mtd.doesExist(OutputWorkspace) else None, OutputWorkspace=OutputWorkspace, AlignedDim0=mtd['__temp'].getDimension(0).name + ',' + BinningDim0, AlignedDim1=mtd['__temp'].getDimension(1).name + ',' + BinningDim1, AlignedDim2=mtd['__temp'].getDimension(2).name + ',' + BinningDim2) DeleteWorkspace('__temp') return OutputWorkspace
def create_pixel_workspace(self, name): sim_workspace = CreateSimulationWorkspace(Instrument='MAR', BinParams=[-10, 1, 10], UnitX='DeltaE', OutputWorkspace=name) AddSampleLog(sim_workspace, LogName='Ei', LogText='3.', LogType='Number') sim_workspace = ConvertToMD(InputWorkspace=sim_workspace, OutputWorkspace=name, QDimensions='|Q|', dEAnalysisMode='Direct', MinValues='-10,0,0', MaxValues='10,6,500', SplitInto='50,50') workspace = wrap_workspace(sim_workspace, name) workspace.is_PSD = True workspace.limits['MomentumTransfer'] = [0.1, 3.1, 0.1] workspace.limits['|Q|'] = [0.1, 3.1, 0.1] workspace.limits['DeltaE'] = [-10, 15, 1] workspace.e_fixed = 10 workspace.ef_defined = True return workspace
def test_property_setup(input_mde: str, reduced_background: str): """Test set up properties :return: """ # Test raise exception for wrong background MDE type try: # Create background workspace in Q lab ConvertToMD(InputWorkspace=reduced_background, QDimensions='Q3D', Q3DFrames='Q_sample', OutputWorkspace='bkgd_md', MinValues='-11,-11,-11,-25', MaxValues='11,11,11,49') MDNorm(InputWorkspace=input_mde, BackgroundWorkspace='bkgd_md', Dimension0Name='QDimension1', Dimension0Binning='-5,0.05,5', Dimension1Name='QDimension2', Dimension1Binning='-5,0.05,5', Dimension2Name='DeltaE', Dimension2Binning='-2,2', Dimension3Name='QDimension0', Dimension3Binning='-0.5,0.5', SymmetryOperations='x,y,z;x,-y,z;x,y,-z;x,-y,-z', OutputWorkspace='result', OutputDataWorkspace='dataMD', OutputNormalizationWorkspace='normMD') DeleteWorkspace(Workspace='bkgd_md') except RuntimeError: pass else: raise AssertionError( f'Expected failure due to Background MD in Q_sample.')
def _determine_single_crystal_diffraction(self): """ All work related to the determination of the diffraction pattern """ a, b, c = self.getProperty('LatticeSizes').value alpha, beta, gamma = self.getProperty('LatticeAngles').value u = self.getProperty('VectorU').value v = self.getProperty('VectorV').value uproj = self.getProperty('Uproj').value vproj = self.getProperty('Vproj').value wproj = self.getProperty('Wproj').value n_bins = self.getProperty('NBins').value self._n_bins = (n_bins, n_bins, 1) axis0 = '{},0,1,0,1'.format(self.getProperty('PsiAngleLog').value) axis1 = '{},0,1,0,1'.format(self.getProperty('PsiOffset').value) # Options for SetUB independent of run ub_args = dict(a=a, b=b, c=c, alpha=alpha, beta=beta, gamma=gamma, u=u, v=v) min_values = None # Options for algorithm ConvertToMD independent of run convert_to_md_kwargs = dict(QDimensions='Q3D', dEAnalysisMode='Elastic', Q3DFrames='HKL', QConversionScales='HKL', Uproj=uproj, Vproj=vproj, Wproj=wproj) md_norm_scd_kwargs = None # Options for algorithm MDNormSCD # Find solid angle and flux if self._vanadium_files: kwargs = dict(Filename='+'.join(self._vanadium_files), MaskFile=self.getProperty("MaskFile").value, MomentumMin=self._momentum_range[0], MomentumMax=self._momentum_range[1]) _t_solid_angle, _t_int_flux = \ MDNormSCDPreprocessIncoherent(**kwargs) else: _t_solid_angle = self.nominal_solid_angle('_t_solid_angle') _t_int_flux = self.nominal_integrated_flux('_t_int_flux') # Process a sample at a time run_numbers = self._getRuns(self.getProperty("RunNumbers").value, doIndiv=True) run_numbers = list(itertools.chain.from_iterable(run_numbers)) diffraction_reporter = Progress(self, start=0.0, end=1.0, nreports=len(run_numbers)) for i_run, run in enumerate(run_numbers): _t_sample = self._mask_t0_crop(run, '_t_sample') # Set Goniometer and UB matrix SetGoniometer(_t_sample, Axis0=axis0, Axis1=axis1) SetUB(_t_sample, **ub_args) if self._bkg: self._bkg.run().getGoniometer().\ setR(_t_sample.run().getGoniometer().getR()) SetUB(self._bkg, **ub_args) # Determine limits for momentum transfer in HKL space. Needs to be # done only once. We use the first run. if min_values is None: kwargs = dict(QDimensions='Q3D', dEAnalysisMode='Elastic', Q3DFrames='HKL') min_values, max_values = ConvertToMDMinMaxGlobal( _t_sample, **kwargs) convert_to_md_kwargs.update({ 'MinValues': min_values, 'MaxValues': max_values }) # Convert to MD _t_md = ConvertToMD(_t_sample, OutputWorkspace='_t_md', **convert_to_md_kwargs) if self._bkg: _t_bkg_md = ConvertToMD(self._bkg, OutputWorkspace='_t_bkg_md', **convert_to_md_kwargs) # Determine aligned dimensions. Need to be done only once if md_norm_scd_kwargs is None: aligned = list() for i_dim in range(3): kwargs = { 'name': _t_md.getDimension(i_dim).name, 'min': min_values[i_dim], 'max': max_values[i_dim], 'n_bins': self._n_bins[i_dim] } aligned.append( '{name},{min},{max},{n_bins}'.format(**kwargs)) md_norm_scd_kwargs = dict(AlignedDim0=aligned[0], AlignedDim1=aligned[1], AlignedDim2=aligned[2], FluxWorkspace=_t_int_flux, SolidAngleWorkspace=_t_solid_angle, SkipSafetyCheck=True) # Normalize sample by solid angle and integrated flux; # Accumulate runs into the temporary workspaces MDNormSCD(_t_md, OutputWorkspace='_t_data', OutputNormalizationWorkspace='_t_norm', TemporaryDataWorkspace='_t_data' if mtd.doesExist('_t_data') else None, TemporaryNormalizationWorkspace='_t_norm' if mtd.doesExist('_t_norm') else None, **md_norm_scd_kwargs) if self._bkg: MDNormSCD(_t_bkg_md, OutputWorkspace='_t_bkg_data', OutputNormalizationWorkspace='_t_bkg_norm', TemporaryDataWorkspace='_t_bkg_data' if mtd.doesExist('_t_bkg_data') else None, TemporaryNormalizationWorkspace='_t_bkg_norm' if mtd.doesExist('_t_bkg_norm') else None, **md_norm_scd_kwargs) message = 'Processing sample {} of {}'.\ format(i_run+1, len(run_numbers)) diffraction_reporter.report(message) self._temps.workspaces.append('PreprocessedDetectorsWS') # to remove # Iteration over the sample runs is done. # Division by vanadium, subtract background, and rename workspaces name = self.getPropertyValue("OutputWorkspace") _t_data = DivideMD(LHSWorkspace='_t_data', RHSWorkspace='_t_norm') if self._bkg: _t_bkg_data = DivideMD(LHSWorkspace='_t_bkg_data', RHSWorkspace='_t_bkg_norm') _t_scale = CreateSingleValuedWorkspace(DataValue=self._bkg_scale) _t_bkg_data = MultiplyMD(_t_bkg_data, _t_scale) ws = MinusMD(_t_data, _t_bkg_data) RenameWorkspace(_t_data, OutputWorkspace=name + '_dat') RenameWorkspace(_t_bkg_data, OutputWorkspace=name + '_bkg') else: ws = _t_data RenameWorkspace(ws, OutputWorkspace=name) self.setProperty("OutputWorkspace", ws) diffraction_reporter.report(len(run_numbers), 'Done')
dtype=np.float).reshape(3, 3) sgl = np.deg2rad(ws.run().getProperty( 'HB2C:Mot:sgl.RBV').value[0]) # 'HB2C:Mot:sgl.RBV,1,0,0,-1' sgu = np.deg2rad(ws.run().getProperty( 'HB2C:Mot:sgu.RBV').value[0]) # 'HB2C:Mot:sgu.RBV,0,0,1,-1' sgl_a = np.array([[1, 0, 0], [0, np.cos(sgl), np.sin(sgl)], [0, -np.sin(sgl), np.cos(sgl)]]) sgu_a = np.array([[np.cos(sgu), np.sin(sgu), 0], [-np.sin(sgu), np.cos(sgu), 0], [0, 0, 1]]) UB = sgl_a.dot(sgu_a).dot( ub) # Apply the Goniometer tilts to the UB matrix SetUB(ws, UB=UB) md = ConvertToMD(ws, QDimensions='Q3D', dEAnalysisMode='Elastic', Q3DFrames='HKL', QConversionScales='HKL', OtherDimensions='HB2C:SE:SampleTemp', MinValues='-10,-10,-10,0', MaxValues='10,10,10,30') if 'data' in mtd: PlusMD(LHSWorkspace='data', RHSWorkspace='md', OutputWorkspace='data') else: CloneMDWorkspace(InputWorkspace='md', OutputWorkspace='data') BinMD(InputWorkspace='data', AlignedDim0='[H,0,0],-1,3,200', AlignedDim1='[0,K,0],0,3,150', AlignedDim2='[0,0,L],-1,3,40', AlignedDim3='HB2C:SE:SampleTemp,0,30,10', OutputWorkspace='bin')
def PyExec(self): # remove possible old temp workspaces [ DeleteWorkspace(ws) for ws in self.temp_workspace_list if mtd.doesExist(ws) ] _background = bool(self.getProperty("Background").value) _load_inst = bool(self.getProperty("LoadInstrument").value) _detcal = bool(self.getProperty("DetCal").value) _masking = bool(self.getProperty("MaskFile").value) _outWS_name = self.getPropertyValue("OutputWorkspace") UBList = self._generate_UBList() dim0_min, dim0_max, dim0_bins = self.getProperty('BinningDim0').value dim1_min, dim1_max, dim1_bins = self.getProperty('BinningDim1').value dim2_min, dim2_max, dim2_bins = self.getProperty('BinningDim2').value MinValues = "{},{},{}".format(dim0_min, dim1_min, dim2_min) MaxValues = "{},{},{}".format(dim0_max, dim1_max, dim2_max) AlignedDim0 = ",{},{},{}".format(dim0_min, dim0_max, int(dim0_bins)) AlignedDim1 = ",{},{},{}".format(dim1_min, dim1_max, int(dim1_bins)) AlignedDim2 = ",{},{},{}".format(dim2_min, dim2_max, int(dim2_bins)) LoadNexus(Filename=self.getProperty("SolidAngle").value, OutputWorkspace='__sa') LoadNexus(Filename=self.getProperty("Flux").value, OutputWorkspace='__flux') if _masking: LoadMask(Instrument=mtd['__sa'].getInstrument().getName(), InputFile=self.getProperty("MaskFile").value, OutputWorkspace='__mask') MaskDetectors(Workspace='__sa', MaskedWorkspace='__mask') DeleteWorkspace('__mask') XMin = mtd['__sa'].getXDimension().getMinimum() XMax = mtd['__sa'].getXDimension().getMaximum() if _background: Load(Filename=self.getProperty("Background").value, OutputWorkspace='__bkg', FilterByTofMin=self.getProperty("FilterByTofMin").value, FilterByTofMax=self.getProperty("FilterByTofMax").value) if _load_inst: LoadInstrument( Workspace='__bkg', Filename=self.getProperty("LoadInstrument").value, RewriteSpectraMap=False) if _detcal: LoadIsawDetCal(InputWorkspace='__bkg', Filename=self.getProperty("DetCal").value) MaskDetectors(Workspace='__bkg', MaskedWorkspace='__sa') ConvertUnits(InputWorkspace='__bkg', OutputWorkspace='__bkg', Target='Momentum') CropWorkspace(InputWorkspace='__bkg', OutputWorkspace='__bkg', XMin=XMin, XMax=XMax) progress = Progress( self, 0.0, 1.0, len(UBList) * len(self.getProperty("Filename").value)) for run in self.getProperty("Filename").value: logger.notice("Working on " + run) Load(Filename=run, OutputWorkspace='__run', FilterByTofMin=self.getProperty("FilterByTofMin").value, FilterByTofMax=self.getProperty("FilterByTofMax").value) if _load_inst: LoadInstrument( Workspace='__run', Filename=self.getProperty("LoadInstrument").value, RewriteSpectraMap=False) if _detcal: LoadIsawDetCal(InputWorkspace='__run', Filename=self.getProperty("DetCal").value) MaskDetectors(Workspace='__run', MaskedWorkspace='__sa') ConvertUnits(InputWorkspace='__run', OutputWorkspace='__run', Target='Momentum') CropWorkspace(InputWorkspace='__run', OutputWorkspace='__run', XMin=XMin, XMax=XMax) if self.getProperty('SetGoniometer').value: SetGoniometer( Workspace='__run', Goniometers=self.getProperty('Goniometers').value, Axis0=self.getProperty('Axis0').value, Axis1=self.getProperty('Axis1').value, Axis2=self.getProperty('Axis2').value) # Set background Goniometer to be the same as data if _background: mtd['__bkg'].run().getGoniometer().setR( mtd['__run'].run().getGoniometer().getR()) for ub in UBList: SetUB(Workspace='__run', UB=ub) ConvertToMD(InputWorkspace='__run', OutputWorkspace='__md', QDimensions='Q3D', dEAnalysisMode='Elastic', Q3DFrames='HKL', QConversionScales='HKL', Uproj=self.getProperty('Uproj').value, Vproj=self.getProperty('Vproj').value, Wproj=self.getProperty('wproj').value, MinValues=MinValues, MaxValues=MaxValues) MDNormSCD( InputWorkspace=mtd['__md'], FluxWorkspace='__flux', SolidAngleWorkspace='__sa', OutputWorkspace='__data', SkipSafetyCheck=True, TemporaryDataWorkspace='__data' if mtd.doesExist('__data') else None, OutputNormalizationWorkspace='__norm', TemporaryNormalizationWorkspace='__norm' if mtd.doesExist('__norm') else None, AlignedDim0=mtd['__md'].getDimension(0).name + AlignedDim0, AlignedDim1=mtd['__md'].getDimension(1).name + AlignedDim1, AlignedDim2=mtd['__md'].getDimension(2).name + AlignedDim2) DeleteWorkspace('__md') if _background: SetUB(Workspace='__bkg', UB=ub) ConvertToMD(InputWorkspace='__bkg', OutputWorkspace='__bkg_md', QDimensions='Q3D', dEAnalysisMode='Elastic', Q3DFrames='HKL', QConversionScales='HKL', Uproj=self.getProperty('Uproj').value, Vproj=self.getProperty('Vproj').value, Wproj=self.getProperty('Wproj').value, MinValues=MinValues, MaxValues=MaxValues) MDNormSCD( InputWorkspace='__bkg_md', FluxWorkspace='__flux', SolidAngleWorkspace='__sa', SkipSafetyCheck=True, OutputWorkspace='__bkg_data', TemporaryDataWorkspace='__bkg_data' if mtd.doesExist('__bkg_data') else None, OutputNormalizationWorkspace='__bkg_norm', TemporaryNormalizationWorkspace='__bkg_norm' if mtd.doesExist('__bkg_norm') else None, AlignedDim0=mtd['__bkg_md'].getDimension(0).name + AlignedDim0, AlignedDim1=mtd['__bkg_md'].getDimension(1).name + AlignedDim1, AlignedDim2=mtd['__bkg_md'].getDimension(2).name + AlignedDim2) DeleteWorkspace('__bkg_md') progress.report() DeleteWorkspace('__run') if _background: # outWS = data / norm - bkg_data / bkg_norm * BackgroundScale DivideMD(LHSWorkspace='__data', RHSWorkspace='__norm', OutputWorkspace=_outWS_name + '_normalizedData') DivideMD(LHSWorkspace='__bkg_data', RHSWorkspace='__bkg_norm', OutputWorkspace=_outWS_name + '_normalizedBackground') CreateSingleValuedWorkspace( OutputWorkspace='__scale', DataValue=self.getProperty('BackgroundScale').value) MultiplyMD(LHSWorkspace=_outWS_name + '_normalizedBackground', RHSWorkspace='__scale', OutputWorkspace='__scaled_background') DeleteWorkspace('__scale') MinusMD(LHSWorkspace=_outWS_name + '_normalizedData', RHSWorkspace='__scaled_background', OutputWorkspace=_outWS_name) if self.getProperty('KeepTemporaryWorkspaces').value: RenameWorkspaces(InputWorkspaces=[ '__data', '__norm', '__bkg_data', '__bkg_norm' ], WorkspaceNames=[ _outWS_name + '_data', _outWS_name + '_normalization', _outWS_name + '_background_data', _outWS_name + '_background_normalization' ]) else: # outWS = data / norm DivideMD(LHSWorkspace='__data', RHSWorkspace='__norm', OutputWorkspace=_outWS_name) if self.getProperty('KeepTemporaryWorkspaces').value: RenameWorkspaces(InputWorkspaces=['__data', '__norm'], WorkspaceNames=[ _outWS_name + '_data', _outWS_name + '_normalization' ]) self.setProperty("OutputWorkspace", mtd[_outWS_name]) # remove temp workspaces [ DeleteWorkspace(ws) for ws in self.temp_workspace_list if mtd.doesExist(ws) ]
def load_and_group(self, runs: List[str]) -> IMDHistoWorkspace: """ Load the data with given grouping """ # grouping config grouping = self.getProperty("Grouping").value if grouping == 'None': grouping = 1 else: grouping = 2 if grouping == '2x2' else 4 number_of_runs = len(runs) x_dim = 480 * 8 // grouping y_dim = 512 // grouping data_array = np.empty((number_of_runs, x_dim, y_dim), dtype=np.float64) s1_array = [] duration_array = [] run_number_array = [] monitor_count_array = [] progress = Progress(self, 0.0, 1.0, number_of_runs + 3) for n, run in enumerate(runs): progress.report('Loading: ' + run) with h5py.File(run, 'r') as f: bc = np.zeros((512 * 480 * 8), dtype=np.int64) for b in range(8): bc += np.bincount(f['/entry/bank' + str(b + 1) + '_events/event_id'].value, minlength=512 * 480 * 8) bc = bc.reshape((480 * 8, 512)) if grouping == 2: bc = bc[::2, ::2] + bc[1::2, ::2] + bc[::2, 1::2] + bc[1::2, 1::2] elif grouping == 4: bc = bc[::4, ::4] + bc[1::4, ::4] + bc[2::4, ::4] + bc[3::4, ::4] + bc[::4, 1::4] + bc[1::4, 1::4] + bc[2::4, 1::4] + \ bc[3::4, 1::4] + bc[::4, 2::4] + bc[1::4, 2::4] + bc[2::4, 2::4] + bc[3::4, 2::4] + bc[::4, 3::4] + \ bc[1::4, 3::4] + bc[2::4, 3::4] + bc[3::4, 3::4] data_array[n] = bc s1_array.append( f['/entry/DASlogs/HB2C:Mot:s1.RBV/average_value'].value[0]) duration_array.append(float(f['/entry/duration'].value[0])) run_number_array.append(float(f['/entry/run_number'].value[0])) monitor_count_array.append( float(f['/entry/monitor1/total_counts'].value[0])) progress.report('Creating MDHistoWorkspace') createWS_alg = self.createChildAlgorithm("CreateMDHistoWorkspace", enableLogging=False) createWS_alg.setProperty("SignalInput", data_array) createWS_alg.setProperty("ErrorInput", np.sqrt(data_array)) createWS_alg.setProperty("Dimensionality", 3) createWS_alg.setProperty( "Extents", '0.5,{},0.5,{},0.5,{}'.format(y_dim + 0.5, x_dim + 0.5, number_of_runs + 0.5)) createWS_alg.setProperty( "NumberOfBins", '{},{},{}'.format(y_dim, x_dim, number_of_runs)) createWS_alg.setProperty("Names", 'y,x,scanIndex') createWS_alg.setProperty("Units", 'bin,bin,number') createWS_alg.execute() outWS = createWS_alg.getProperty("OutputWorkspace").value progress.report('Getting IDF') # Get the instrument and some logs from the first file; assume the rest are the same _tmp_ws = LoadEventNexus(runs[0], MetaDataOnly=True, EnableLogging=False) # The following logs should be the same for all runs RemoveLogs( _tmp_ws, KeepLogs= 'HB2C:Mot:detz,HB2C:Mot:detz.RBV,HB2C:Mot:s2,HB2C:Mot:s2.RBV,' 'HB2C:Mot:sgl,HB2C:Mot:sgl.RBV,HB2C:Mot:sgu,HB2C:Mot:sgu.RBV,' 'run_title,start_time,experiment_identifier,HB2C:CS:CrystalAlign:UBMatrix', EnableLogging=False) time_ns_array = _tmp_ws.run().startTime().totalNanoseconds( ) + np.append(0, np.cumsum(duration_array) * 1e9)[:-1] try: ub = np.array(re.findall( r'-?\d+\.*\d*', _tmp_ws.run().getProperty( 'HB2C:CS:CrystalAlign:UBMatrix').value[0]), dtype=float).reshape(3, 3) sgl = np.deg2rad(_tmp_ws.run().getProperty( 'HB2C:Mot:sgl.RBV').value[0]) # 'HB2C:Mot:sgl.RBV,1,0,0,-1' sgu = np.deg2rad(_tmp_ws.run().getProperty( 'HB2C:Mot:sgu.RBV').value[0]) # 'HB2C:Mot:sgu.RBV,0,0,1,-1' sgl_a = np.array([[1, 0, 0], [0, np.cos(sgl), np.sin(sgl)], [0, -np.sin(sgl), np.cos(sgl)]]) sgu_a = np.array([[np.cos(sgu), np.sin(sgu), 0], [-np.sin(sgu), np.cos(sgu), 0], [0, 0, 1]]) UB = sgl_a.dot(sgu_a).dot( ub) # Apply the Goniometer tilts to the UB matrix SetUB(_tmp_ws, UB=UB, EnableLogging=False) except (RuntimeError, ValueError): SetUB(_tmp_ws, EnableLogging=False) if grouping > 1: _tmp_group, _, _ = CreateGroupingWorkspace(InputWorkspace=_tmp_ws, EnableLogging=False) group_number = 0 for x in range(0, 480 * 8, grouping): for y in range(0, 512, grouping): group_number += 1 for j in range(grouping): for i in range(grouping): _tmp_group.dataY(y + i + (x + j) * 512)[0] = group_number _tmp_ws = GroupDetectors(InputWorkspace=_tmp_ws, CopyGroupingFromWorkspace=_tmp_group, EnableLogging=False) DeleteWorkspace(_tmp_group, EnableLogging=False) progress.report('Adding logs') # Hack: ConvertToMD is needed so that a deep copy of the ExperimentInfo can happen # outWS.addExperimentInfo(_tmp_ws) # This doesn't work but should, when you delete `ws` `outWS` also loses it's ExperimentInfo _tmp_ws = Rebin(_tmp_ws, '0,1,2', EnableLogging=False) _tmp_ws = ConvertToMD(_tmp_ws, dEAnalysisMode='Elastic', EnableLogging=False, PreprocDetectorsWS='__PreprocessedDetectorsWS') preprocWS = mtd['__PreprocessedDetectorsWS'] twotheta = preprocWS.column(2) azimuthal = preprocWS.column(3) outWS.copyExperimentInfos(_tmp_ws) DeleteWorkspace(_tmp_ws, EnableLogging=False) DeleteWorkspace('__PreprocessedDetectorsWS', EnableLogging=False) # end Hack add_time_series_property('s1', outWS.getExperimentInfo(0).run(), time_ns_array, s1_array) outWS.getExperimentInfo(0).run().getProperty('s1').units = 'deg' add_time_series_property('duration', outWS.getExperimentInfo(0).run(), time_ns_array, duration_array) outWS.getExperimentInfo(0).run().getProperty( 'duration').units = 'second' outWS.getExperimentInfo(0).run().addProperty('run_number', run_number_array, True) add_time_series_property('monitor_count', outWS.getExperimentInfo(0).run(), time_ns_array, monitor_count_array) outWS.getExperimentInfo(0).run().addProperty('twotheta', twotheta, True) outWS.getExperimentInfo(0).run().addProperty('azimuthal', azimuthal, True) setGoniometer_alg = self.createChildAlgorithm("SetGoniometer", enableLogging=False) setGoniometer_alg.setProperty("Workspace", outWS) setGoniometer_alg.setProperty("Axis0", 's1,0,1,0,1') setGoniometer_alg.setProperty("Average", False) setGoniometer_alg.execute() return outWS
run1 = 'CORELLI_48505' run2 = 'CORELLI_48513' run1 = 'CORELLI_48508' run2 = 'CORELLI_48516' ws1 = Load(run1) ws2 = Load(run2) SetGoniometer(ws1, Axis0="BL9:Mot:Sample:Axis2,0,1,0,1") SetGoniometer(ws2, Axis0="BL9:Mot:Sample:Axis2,0,1,0,1") md1 = ConvertToMD(ws1, QDimensions='Q3D', dEAnalysisMode='Elastic', Q3DFrames='Q_sample', MinValues=[-10, -10, -10], MaxValues=[10, 10, 10]) md2 = ConvertToMD(ws2, QDimensions='Q3D', dEAnalysisMode='Elastic', Q3DFrames='Q_sample', MinValues=[-10, -10, -10], MaxValues=[10, 10, 10]) bin1 = BinMD(md1, AlignedDim0='Q_sample_x,-10,10,1000', AlignedDim1='Q_sample_z,-10,10,1000', AlignedDim2='Q_sample_y,-10,10,1') bin2 = BinMD(md2, AlignedDim0='Q_sample_x,-10,10,1000',
def PyExec(self): # remove possible old temp workspaces [ DeleteWorkspace(ws) for ws in self.temp_workspace_list if mtd.doesExist(ws) ] _background = bool(self.getProperty("Background").value) self._load_inst = bool(self.getProperty("LoadInstrument").value) self._apply_cal = bool(self.getProperty("ApplyCalibration").value) self._detcal = bool(self.getProperty("DetCal").value) self._copy_params = bool( self.getProperty("CopyInstrumentParameters").value) _masking = bool(self.getProperty("MaskFile").value) _outWS_name = self.getPropertyValue("OutputWorkspace") _UB = self.getProperty("UBMatrix").value if len(_UB) == 1: _UB = np.tile(_UB, len(self.getProperty("Filename").value)) _offsets = self.getProperty("OmegaOffset").value if len(_offsets) == 0: _offsets = np.zeros(len(self.getProperty("Filename").value)) if self.getProperty("ReuseSAFlux").value and mtd.doesExist( '__sa') and mtd.doesExist('__flux'): logger.notice( "Reusing previously loaded SolidAngle and Flux workspaces. " "Set ReuseSAFlux to False if new files are selected or you change the momentum range." ) else: logger.notice("Loading SolidAngle and Flux from file") LoadNexus(Filename=self.getProperty("SolidAngle").value, OutputWorkspace='__sa') LoadNexus(Filename=self.getProperty("Flux").value, OutputWorkspace='__flux') if _masking: LoadMask(Instrument=mtd['__sa'].getInstrument().getName(), InputFile=self.getProperty("MaskFile").value, OutputWorkspace='__mask') MaskDetectors(Workspace='__sa', MaskedWorkspace='__mask') DeleteWorkspace('__mask') self.XMin = mtd['__sa'].getXDimension().getMinimum() self.XMax = mtd['__sa'].getXDimension().getMaximum() newXMin = self.getProperty("MomentumMin").value newXMax = self.getProperty("MomentumMax").value if newXMin != Property.EMPTY_DBL or newXMax != Property.EMPTY_DBL: if newXMin != Property.EMPTY_DBL: self.XMin = max(self.XMin, newXMin) if newXMax != Property.EMPTY_DBL: self.XMax = min(self.XMax, newXMax) logger.notice("Using momentum range {} to {} A^-1".format( self.XMin, self.XMax)) CropWorkspace(InputWorkspace='__flux', OutputWorkspace='__flux', XMin=self.XMin, XMax=self.XMax) for spectrumNumber in range(mtd['__flux'].getNumberHistograms()): Y = mtd['__flux'].readY(spectrumNumber) mtd['__flux'].setY(spectrumNumber, (Y - Y.min()) / (Y.max() - Y.min())) MinValues = [-self.XMax * 2] * 3 MaxValues = [self.XMax * 2] * 3 if _background: self.load_file_and_apply( self.getProperty("Background").value, '__bkg', 0) progress = Progress(self, 0.0, 1.0, len(self.getProperty("Filename").value)) for n, run in enumerate(self.getProperty("Filename").value): logger.notice("Working on " + run) self.load_file_and_apply(run, '__run', _offsets[n]) LoadIsawUB('__run', _UB[n]) ConvertToMD(InputWorkspace='__run', OutputWorkspace='__md', QDimensions='Q3D', dEAnalysisMode='Elastic', Q3DFrames='Q_sample', MinValues=MinValues, MaxValues=MaxValues) RecalculateTrajectoriesExtents(InputWorkspace='__md', OutputWorkspace='__md') MDNorm( InputWorkspace='__md', FluxWorkspace='__flux', SolidAngleWorkspace='__sa', OutputDataWorkspace='__data', TemporaryDataWorkspace='__data' if mtd.doesExist('__data') else None, OutputNormalizationWorkspace='__norm', TemporaryNormalizationWorkspace='__norm' if mtd.doesExist('__norm') else None, OutputWorkspace=_outWS_name, QDimension0=self.getProperty('QDimension0').value, QDimension1=self.getProperty('QDimension1').value, QDimension2=self.getProperty('QDimension2').value, Dimension0Binning=self.getProperty('Dimension0Binning').value, Dimension1Binning=self.getProperty('Dimension1Binning').value, Dimension2Binning=self.getProperty('Dimension2Binning').value, SymmetryOperations=self.getProperty( 'SymmetryOperations').value) DeleteWorkspace('__md') if _background: # Set background Goniometer and UB to be the same as data CopySample(InputWorkspace='__run', OutputWorkspace='__bkg', CopyName=False, CopyMaterial=False, CopyEnvironment=False, CopyShape=False, CopyLattice=True) mtd['__bkg'].run().getGoniometer().setR( mtd['__run'].run().getGoniometer().getR()) ConvertToMD(InputWorkspace='__bkg', OutputWorkspace='__bkg_md', QDimensions='Q3D', dEAnalysisMode='Elastic', Q3DFrames='Q_sample', MinValues=MinValues, MaxValues=MaxValues) RecalculateTrajectoriesExtents(InputWorkspace='__bkg_md', OutputWorkspace='__bkg_md') MDNorm(InputWorkspace='__bkg_md', FluxWorkspace='__flux', SolidAngleWorkspace='__sa', OutputDataWorkspace='__bkg_data', TemporaryDataWorkspace='__bkg_data' if mtd.doesExist('__bkg_data') else None, OutputNormalizationWorkspace='__bkg_norm', TemporaryNormalizationWorkspace='__bkg_norm' if mtd.doesExist('__bkg_norm') else None, OutputWorkspace='__normalizedBackground', QDimension0=self.getProperty('QDimension0').value, QDimension1=self.getProperty('QDimension1').value, QDimension2=self.getProperty('QDimension2').value, Dimension0Binning=self.getProperty( 'Dimension0Binning').value, Dimension1Binning=self.getProperty( 'Dimension1Binning').value, Dimension2Binning=self.getProperty( 'Dimension2Binning').value, SymmetryOperations=self.getProperty( 'SymmetryOperations').value) DeleteWorkspace('__bkg_md') progress.report() DeleteWorkspace('__run') if _background: # outWS = data / norm - bkg_data / bkg_norm * BackgroundScale CreateSingleValuedWorkspace( OutputWorkspace='__scale', DataValue=self.getProperty('BackgroundScale').value) MultiplyMD(LHSWorkspace='__normalizedBackground', RHSWorkspace='__scale', OutputWorkspace='__normalizedBackground') DeleteWorkspace('__scale') MinusMD(LHSWorkspace=_outWS_name, RHSWorkspace='__normalizedBackground', OutputWorkspace=_outWS_name) if self.getProperty('KeepTemporaryWorkspaces').value: RenameWorkspaces(InputWorkspaces=[ '__data', '__norm', '__bkg_data', '__bkg_norm' ], WorkspaceNames=[ _outWS_name + '_data', _outWS_name + '_normalization', _outWS_name + '_background_data', _outWS_name + '_background_normalization' ]) else: if self.getProperty('KeepTemporaryWorkspaces').value: RenameWorkspaces(InputWorkspaces=['__data', '__norm'], WorkspaceNames=[ _outWS_name + '_data', _outWS_name + '_normalization' ]) self.setProperty("OutputWorkspace", mtd[_outWS_name]) # remove temp workspaces [ DeleteWorkspace(ws) for ws in self.temp_workspace_list if mtd.doesExist(ws) ]
elif Chopperpos < 1: Chopper = 1 else: Chopper = 0 # generate a nice 2D multi-dimensional workspace data = LoadNXSPE(datadir + 'ARCS_' + str(RunNumber) + '_autoreduced.nxspe') values = ConvertToMDMinMaxLocal('data', QDimensions='|Q|', dEAnalysisMode='Direct') minQ, minE = values.MinValues maxQ, maxE = values.MaxValues md = ConvertToMD(InputWorkspace=data, QDimensions='|Q|', dEAnalysisMode='Direct') sqw = BinMD(InputWorkspace=md, AlignedDim0='|Q|,' + str(minQ) + ',' + str(maxQ) + ',100', AlignedDim1='DeltaE,' + str(minE) + ',' + str(maxE * 0.8) + ',100') #2D plot if PlotTag == 1: fig, ax = plt.subplots(subplot_kw={'projection': 'mantid'}) c = ax.pcolormesh(sqw, vmin=0., vmax=0.5e-3) cbar = fig.colorbar(c) cbar.set_label('Intensity (arb. units)') #add text to colorbar ax.set_title('Run ' + str(RunNumber) + ',Ei=' + str(Energy) + 'meVChoppers=[' + str(Chopper1) + ',' + str(Chopper2) + ',' + str(Chopper3) + ']')
# #Subtract instrument background temp = bkg * (proton_charge / bkg_proton_charge) * (float(BN_aperture_size) / 2.0) # Ratio of background counts to 2 mm diameter BN aperture event_ws = Minus(LHSWorkspace=event_ws, RHSWorkspace=temp) # # Make MD workspace using Lorentz correction, to find peaks # MDEW = ConvertToMD(InputWorkspace=event_ws, QDimensions="Q3D", dEAnalysisMode="Elastic", QConversionScales="Q in A^-1", LorentzCorrection='1', MinValues=minQ, MaxValues=maxQ, SplitInto='2', SplitThreshold=split_threshold, MaxRecursionDepth='11') # # Find the requested number of peaks. Once the peaks are found, we no longer # need the weighted MD event workspace, so delete it. # distance_threshold = 0.9 * 6.28 / float(max_d) peaks_ws = FindPeaksMD(MDEW, MaxPeaks=num_peaks_to_find, DensityThresholdFactor='5', PeakDistanceThreshold=distance_threshold) #Remove peaks on detector edge
def PyExec(self): self._load_inst = bool(self.getProperty("LoadInstrument").value) self._apply_cal = bool(self.getProperty("ApplyCalibration").value) self._detcal = bool(self.getProperty("DetCal").value) self._copy_params = bool( self.getProperty("CopyInstrumentParameters").value) self._masking = bool(self.getProperty("MaskFile").value) _outWS_name = self.getPropertyValue("OutputWorkspace") _UB = bool(self.getProperty("UBMatrix").value) self.XMin = self.getProperty("MomentumMin").value self.XMax = self.getProperty("MomentumMax").value MinValues = self.getProperty("MinValues").value MaxValues = self.getProperty("MaxValues").value if self.getProperty("OverwriteExisting").value: if mtd.doesExist(_outWS_name): DeleteWorkspace(_outWS_name) progress = Progress(self, 0.0, 1.0, len(self.getProperty("Filename").value)) for run in self.getProperty("Filename").value: logger.notice("Working on " + run) self.load_file_and_apply(run, '__run') if self.getProperty('SetGoniometer').value: SetGoniometer( Workspace='__run', Goniometers=self.getProperty('Goniometers').value, Axis0=self.getProperty('Axis0').value, Axis1=self.getProperty('Axis1').value, Axis2=self.getProperty('Axis2').value) if _UB: LoadIsawUB(InputWorkspace='__run', Filename=self.getProperty("UBMatrix").value) if len(MinValues) == 0 or len(MaxValues) == 0: MinValues, MaxValues = ConvertToMDMinMaxGlobal( '__run', dEAnalysisMode='Elastic', Q3DFrames='Q' if self.getProperty('QFrame').value == 'Q_sample' else 'HKL', QDimensions='Q3D') ConvertToMD( InputWorkspace='__run', OutputWorkspace=_outWS_name, QDimensions='Q3D', dEAnalysisMode='Elastic', Q3DFrames=self.getProperty('QFrame').value, QConversionScales='Q in A^-1' if self.getProperty('QFrame').value == 'Q_sample' else 'HKL', Uproj=self.getProperty('Uproj').value, Vproj=self.getProperty('Vproj').value, Wproj=self.getProperty('Wproj').value, MinValues=MinValues, MaxValues=MaxValues, SplitInto=self.getProperty('SplitInto').value, SplitThreshold=self.getProperty('SplitThreshold').value, MaxRecursionDepth=self.getProperty('MaxRecursionDepth').value, OverwriteExisting=False) DeleteWorkspace('__run') progress.report() if mtd.doesExist('__mask'): DeleteWorkspace('__mask') self.setProperty("OutputWorkspace", mtd[_outWS_name])
def prepare_md(input_ws_name, merged_md_name, min_log_value, max_log_value, log_step, prefix) -> str: """Load raw event Nexus file and reduce to MDEventWorkspace """ # Filter gef_kw_dict = dict() if log_step <= max_log_value - min_log_value: LogValueInterval = log_step gef_kw_dict['LogValueInterval'] = LogValueInterval GenerateEventsFilter(InputWorkspace=input_ws_name, OutputWorkspace='splboth', InformationWorkspace='info', UnitOfTime='Nanoseconds', LogName='s1', MinimumLogValue=min_log_value, MaximumLogValue=max_log_value, **gef_kw_dict) FilterEvents(InputWorkspace=input_ws_name, SplitterWorkspace='splboth', InformationWorkspace='info', FilterByPulseTime=True, GroupWorkspaces=True, OutputWorkspaceIndexedFrom1=True, OutputWorkspaceBaseName='split') # Clean memory DeleteWorkspace('splboth') DeleteWorkspace('info') reduced_ws_group = f'reduced_{prefix}' DgsReduction(SampleInputWorkspace='split', SampleInputMonitorWorkspace='split_1', IncidentEnergyGuess=50, SofPhiEIsDistribution=False, TimeIndepBackgroundSub=True, TibTofRangeStart=10400, TibTofRangeEnd=12400, OutputWorkspace=reduced_ws_group) # Clean memory DeleteWorkspace('split') SetUB(Workspace=reduced_ws_group, a=5.823, b=6.475, c=3.186, u='0,1,0', v='0,0,1') CropWorkspaceForMDNorm(InputWorkspace=reduced_ws_group, XMin=-25, XMax=49, OutputWorkspace=reduced_ws_group) ConvertToMD(InputWorkspace=reduced_ws_group, QDimensions='Q3D', Q3DFrames='Q_sample', OutputWorkspace='md', MinValues='-11,-11,-11,-25', MaxValues='11,11,11,49') if mtd['md'].getNumberOfEntries() == 1: RenameWorkspace(mtd['md'][0], merged_md_name) else: MergeMD(InputWorkspaces='md', OutputWorkspace=merged_md_name) return reduced_ws_group
DeleteWorkspace(name_MDE) for run in range(first_run, last_run + 1, load_every): if use_autoreduced: filename = iptsdir + 'shared/autoreduce/HB2C_{}_MDE.nxs'.format(run) try: LoadMD(Filename=filename, LoadHistory=False, OutputWorkspace='__md') except ValueError: filename = iptsdir + 'nexus/HB2C_{}.nxs.h5'.format(run) LoadWAND(filename, OutputWorkspace='__ws') ConvertToMD('__ws', QDimensions='Q3D', dEAnalysisMode='Elastic', Q3DFrames='Q_sample', OutputWorkspace='__md', MinValues='-10,-1,-10', MaxValues='10,1,10') accumulateMD('__md', OutputWorkspace=name_MDE) SaveMD( name_MDE, iptsdir + 'shared/' + name + '_MDE_{}_to_{}_every_{}.nxs'.format(first_run, last_run, load_every)) # Convert MD Event workspace to MD Histo workspace name_MDH = name + '_MDH' BinMD(InputWorkspace=name_MDE, AlignedDim0='Q_sample_x,' + BinningDim0,
def _determine_single_crystal_diffraction(self): """ All work related to the determination of the diffraction pattern """ a, b, c = self.getProperty('LatticeSizes').value alpha, beta, gamma = self.getProperty('LatticeAngles').value u = self.getProperty('VectorU').value v = self.getProperty('VectorV').value uproj = self.getProperty('Uproj').value vproj = self.getProperty('Vproj').value wproj = self.getProperty('Wproj').value n_bins = self.getProperty('NBins').value self._n_bins = (n_bins, n_bins, 1) axis0 = '{},0,1,0,1'.format(self.getProperty('PsiAngleLog').value) axis1 = '{},0,1,0,1'.format(self.getProperty('PsiOffset').value) # Options for SetUB independent of run ub_args = dict(a=a, b=b, c=c, alpha=alpha, beta=beta, gamma=gamma, u=u, v=v) min_values = None # Options for algorithm ConvertToMD independent of run cmd_args = dict(QDimensions='Q3D', dEAnalysisMode='Elastic', Q3DFrames='HKL', QConversionScales='HKL', Uproj=uproj, Vproj=vproj, Wproj=wproj) mdn_args = None # Options for algorithm MDNormSCD # Find solid angle and flux if self._vanadium_files: kwargs = dict(Filename='+'.join(self._vanadium_files), MaskFile=self.getProperty("MaskFile").value, MomentumMin=self._momentum_range[0], MomentumMax=self._momentum_range[1]) _t_solid_angle, _t_int_flux = \ MDNormSCDPreprocessIncoherent(**kwargs) else: _t_solid_angle = self.nominal_solid_angle('_t_solid_angle') _t_int_flux = self.nominal_integrated_flux('_t_int_flux') # Process a sample at a time run_numbers = self._getRuns(self.getProperty("RunNumbers").value, doIndiv=True) run_numbers = list(itertools.chain.from_iterable(run_numbers)) diffraction_reporter = Progress(self, start=0.0, end=1.0, nreports=len(run_numbers)) for i_run, run in enumerate(run_numbers): _t_sample = self._mask_t0_crop(run, '_t_sample') # Set Goniometer and UB matrix SetGoniometer(_t_sample, Axis0=axis0, Axis1=axis1) SetUB(_t_sample, **ub_args) if self._bkg: self._bkg.run().getGoniometer().\ setR(_t_sample.run().getGoniometer().getR()) SetUB(self._bkg, **ub_args) # Determine limits for momentum transfer in HKL space. Needs to be # done only once. We use the first run. if min_values is None: kwargs = dict(QDimensions='Q3D', dEAnalysisMode='Elastic', Q3DFrames='HKL') min_values, max_values = ConvertToMDMinMaxGlobal(_t_sample, **kwargs) cmd_args.update({'MinValues': min_values, 'MaxValues': max_values}) # Convert to MD _t_md = ConvertToMD(_t_sample, OutputWorkspace='_t_md', **cmd_args) if self._bkg: _t_bkg_md = ConvertToMD(self._bkg, OutputWorkspace='_t_bkg_md', **cmd_args) # Determine aligned dimensions. Need to be done only once if mdn_args is None: aligned = list() for i_dim in range(3): kwargs = {'name': _t_md.getDimension(i_dim).name, 'min': min_values[i_dim], 'max': max_values[i_dim], 'n_bins': self._n_bins[i_dim]} aligned.append( '{name},{min},{max},{n_bins}'.format(**kwargs)) mdn_args = dict(AlignedDim0=aligned[0], AlignedDim1=aligned[1], AlignedDim2=aligned[2], FluxWorkspace=_t_int_flux, SolidAngleWorkspace=_t_solid_angle, SkipSafetyCheck=True) # Normalize sample by solid angle and integrated flux; # Accumulate runs into the temporary workspaces MDNormSCD(_t_md, OutputWorkspace='_t_data', OutputNormalizationWorkspace='_t_norm', TemporaryDataWorkspace='_t_data' if mtd.doesExist('_t_data') else None, TemporaryNormalizationWorkspace='_t_norm' if mtd.doesExist('_t_norm') else None, **mdn_args) if self._bkg: MDNormSCD(_t_bkg_md, OutputWorkspace='_t_bkg_data', OutputNormalizationWorkspace='_t_bkg_norm', TemporaryDataWorkspace='_t_bkg_data' if mtd.doesExist('_t_bkg_data') else None, TemporaryNormalizationWorkspace='_t_bkg_norm' if mtd.doesExist('_t_bkg_norm') else None, **mdn_args) message = 'Processing sample {} of {}'.\ format(i_run+1, len(run_numbers)) diffraction_reporter.report(message) self._temps.workspaces.append('PreprocessedDetectorsWS') # to remove # Iteration over the sample runs is done. # Division by vanadium, subtract background, and rename workspaces name = self.getPropertyValue("OutputWorkspace") _t_data = DivideMD(LHSWorkspace='_t_data', RHSWorkspace='_t_norm') if self._bkg: _t_bkg_data = DivideMD(LHSWorkspace='_t_bkg_data', RHSWorkspace='_t_bkg_norm') _t_scale = CreateSingleValuedWorkspace(DataValue=self._bkg_scale) _t_bkg_data = MultiplyMD(_t_bkg_data, _t_scale) ws = MinusMD(_t_data, _t_bkg_data) RenameWorkspace(_t_data, OutputWorkspace=name + '_dat') RenameWorkspace(_t_bkg_data, OutputWorkspace=name + '_bkg') else: ws = _t_data RenameWorkspace(ws, OutputWorkspace=name) self.setProperty("OutputWorkspace", ws) diffraction_reporter.report(len(run_numbers), 'Done')
def PyExec(self): _load_inst = bool(self.getProperty("LoadInstrument").value) _detcal = bool(self.getProperty("DetCal").value) _masking = bool(self.getProperty("MaskFile").value) _outWS_name = self.getPropertyValue("OutputWorkspace") _UB = bool(self.getProperty("UBMatrix").value) MinValues = self.getProperty("MinValues").value MaxValues = self.getProperty("MaxValues").value if self.getProperty("OverwriteExisting").value: if mtd.doesExist(_outWS_name): DeleteWorkspace(_outWS_name) progress = Progress(self, 0.0, 1.0, len(self.getProperty("Filename").value)) for run in self.getProperty("Filename").value: logger.notice("Working on " + run) Load(Filename=run, OutputWorkspace='__run', FilterByTofMin=self.getProperty("FilterByTofMin").value, FilterByTofMax=self.getProperty("FilterByTofMax").value, FilterByTimeStop=self.getProperty("FilterByTimeStop").value) if _load_inst: LoadInstrument( Workspace='__run', Filename=self.getProperty("LoadInstrument").value, RewriteSpectraMap=False) if _detcal: LoadIsawDetCal(InputWorkspace='__run', Filename=self.getProperty("DetCal").value) if _masking: if not mtd.doesExist('__mask'): LoadMask(Instrument=mtd['__run'].getInstrument().getName(), InputFile=self.getProperty("MaskFile").value, OutputWorkspace='__mask') MaskDetectors(Workspace='__run', MaskedWorkspace='__mask') if self.getProperty('SetGoniometer').value: SetGoniometer( Workspace='__run', Goniometers=self.getProperty('Goniometers').value, Axis0=self.getProperty('Axis0').value, Axis1=self.getProperty('Axis1').value, Axis2=self.getProperty('Axis2').value) if _UB: LoadIsawUB(InputWorkspace='__run', Filename=self.getProperty("UBMatrix").value) if len(MinValues) == 0 or len(MaxValues) == 0: MinValues, MaxValues = ConvertToMDMinMaxGlobal( '__run', dEAnalysisMode='Elastic', Q3DFrames='HKL', QDimensions='Q3D') ConvertToMD( InputWorkspace='__run', OutputWorkspace=_outWS_name, QDimensions='Q3D', dEAnalysisMode='Elastic', Q3DFrames='HKL', QConversionScales='HKL', Uproj=self.getProperty('Uproj').value, Vproj=self.getProperty('Vproj').value, Wproj=self.getProperty('Wproj').value, MinValues=MinValues, MaxValues=MaxValues, SplitInto=self.getProperty('SplitInto').value, SplitThreshold=self.getProperty('SplitThreshold').value, MaxRecursionDepth=self.getProperty( 'MaxRecursionDepth').value, OverwriteExisting=False) else: if len(MinValues) == 0 or len(MaxValues) == 0: MinValues, MaxValues = ConvertToMDMinMaxGlobal( '__run', dEAnalysisMode='Elastic', Q3DFrames='Q', QDimensions='Q3D') ConvertToMD( InputWorkspace='__run', OutputWorkspace=_outWS_name, QDimensions='Q3D', dEAnalysisMode='Elastic', Q3DFrames='Q_sample', Uproj=self.getProperty('Uproj').value, Vproj=self.getProperty('Vproj').value, Wproj=self.getProperty('Wproj').value, MinValues=MinValues, MaxValues=MaxValues, SplitInto=self.getProperty('SplitInto').value, SplitThreshold=self.getProperty('SplitThreshold').value, MaxRecursionDepth=self.getProperty( 'MaxRecursionDepth').value, OverwriteExisting=False) DeleteWorkspace('__run') progress.report() if mtd.doesExist('__mask'): DeleteWorkspace('__mask') self.setProperty("OutputWorkspace", mtd[_outWS_name])
def reduce(nxsfile, qaxis, outfile, use_ei_guess=False, ei_guess=None, eaxis=None, tof2E=True, ibnorm='ByCurrent'): from mantid.simpleapi import DgsReduction, SofQW3, SaveNexus, LoadInstrument, Load, MoveInstrumentComponent, \ MaskBTP, ConvertToMD, BinMD, ConvertMDHistoToMatrixWorkspace, GetEiT0atSNS, GetEi from mantid import mtd ws = Load(nxsfile) if tof2E == 'guess': axis = ws.getAxis(0).getUnit().caption().lower() # axis name should be "Time-of-flight" tof2E = "time" in axis and "flight" in axis if tof2E: # mask packs around beam # MaskBTP(ws, Bank="98-102") if not use_ei_guess: run = ws.getRun() Efixed = run.getLogData('mcvine-Ei').value T0 = run.getLogData('mcvine-t0').value else: Efixed, T0 = ei_guess, 0 DgsReduction( SampleInputWorkspace=ws, IncidentEnergyGuess=Efixed, UseIncidentEnergyGuess=True, TimeZeroGuess=T0, OutputWorkspace='reduced', EnergyTransferRange=eaxis, IncidentBeamNormalisation=ibnorm, ) reduced = mtd['reduced'] else: reduced = Load(nxsfile) # if eaxis is not specified, use the data in reduced workspace if eaxis is None: Edim = reduced.getXDimension() emin = Edim.getMinimum() emax = Edim.getMaximum() de = Edim.getX(1) - Edim.getX(0) eaxis = emin, de, emax qmin, dq, qmax = qaxis nq = int(round((qmax - qmin) / dq)) emin, de, emax = eaxis ne = int(round((emax - emin) / de)) md = ConvertToMD( InputWorkspace='reduced', QDimensions='|Q|', dEAnalysisMode='Direct', MinValues="%s,%s" % (qmin, emin), MaxValues="%s,%s" % (qmax, emax), SplitInto="%s,%s" % (nq, ne), ) binned = BinMD( InputWorkspace=md, AxisAligned=1, AlignedDim0="|Q|,%s,%s,%s" % (qmin, qmax, nq), AlignedDim1="DeltaE,%s,%s,%s" % (emin, emax, ne), ) # convert to histogram import histogram as H, histogram.hdf as hh data = binned.getSignalArray().copy() err2 = binned.getErrorSquaredArray().copy() nev = binned.getNumEventsArray() data /= nev err2 /= (nev * nev) qaxis = H.axis('Q', boundaries=np.arange(qmin, qmax + dq / 2., dq), unit='1./angstrom') eaxis = H.axis('E', boundaries=np.arange(emin, emax + de / 2., de), unit='meV') hist = H.histogram('IQE', (qaxis, eaxis), data=data, errors=err2) if outfile.endswith('.nxs'): import warnings warnings.warn( "reduce function no longer writes iqe.nxs nexus file. it only writes iqe.h5 histogram file" ) outfile = outfile[:-4] + '.h5' hh.dump(hist, outfile) return
max_d = 20 tolerance = 0.12 minVals = "-" + max_Q + ",-" + max_Q + ",-" + max_Q maxVals = max_Q + "," + max_Q + "," + max_Q distance_threshold = 0.9 * 6.28 / float(max_d) for f in files: data = Load(f) SetGoniometer(data, Axis0="BL9:Mot:Sample:Axis1,0,1,0,1") MDEW = ConvertToMD(InputWorkspace=data, QDimensions="Q3D", dEAnalysisMode="Elastic", QConversionScales="Q in A^-1", LorentzCorrection='0', MinValues=minVals, MaxValues=maxVals, SplitInto='2', SplitThreshold='50', MaxRecursionDepth='11') peaks_ws = FindPeaksMD(MDEW, MaxPeaks=num_peaks_to_find, PeakDistanceThreshold=distance_threshold, AppendPeaks=True) FindUBUsingFFT(PeaksWorkspace=peaks_ws, MinD=min_d, MaxD=max_d, Tolerance=tolerance) IndexPeaks(PeaksWorkspace=peaks_ws, Tolerance=tolerance) #SaveIsawUB( InputWorkspace=peaks_ws,Filename=run_niggli_matrix_file )