def convertQSampleToHKL(ws, OutputWorkspace='__md_hkl', norm=None, UB=None, Extents=[-10, 10, -10, 10, -10, 10], Bins=[101, 101, 101], Append=False): ol = OrientedLattice() ol.setUB(UB) q1 = ol.qFromHKL([1, 0, 0]) q2 = ol.qFromHKL([0, 1, 0]) q3 = ol.qFromHKL([0, 0, 1]) BinMD(InputWorkspace=ws, AxisAligned=False, NormalizeBasisVectors=False, BasisVector0='[H,0,0],A^-1,{},{},{}'.format(q1.X(), q1.Y(), q1.Z()), BasisVector1='[0,K,0],A^-1,{},{},{}'.format(q2.X(), q2.Y(), q2.Z()), BasisVector2='[0,0,L],A^-1,{},{},{}'.format(q3.X(), q3.Y(), q3.Z()), OutputExtents=Extents, OutputBins=Bins, TemporaryDataWorkspace=OutputWorkspace if Append and mtd.doesExist(OutputWorkspace) else None, OutputWorkspace=OutputWorkspace) if norm is not None: mtd[str(norm)].run().getGoniometer().setR( mtd[str(ws)].getExperimentInfo(0).run().getGoniometer().getR()) convertToHKL(norm, OutputWorkspace=str(OutputWorkspace) + '_norm', UB=UB, Extents=Extents, Bins=Bins, Append=Append) return OutputWorkspace
def test_qFromHLK_input_types(self): ''' Test that you can provide input hkl values as different python types. ''' ol = OrientedLattice(1,1,1) self.assertTrue(isinstance( ol.qFromHKL(V3D(1,1,1)), V3D), "Should work with V3D input") self.assertTrue(isinstance( ol.qFromHKL([1,1,1]), V3D), "Should work with python array input" ) self.assertTrue(isinstance( ol.qFromHKL(np.array([1,1,1])), V3D), "Should work with numpy array input" )
def test_qFromHLK_input_types(self): ''' Test that you can provide input hkl values as different python types. ''' ol = OrientedLattice(1, 1, 1) self.assertTrue(isinstance(ol.qFromHKL(V3D(1, 1, 1)), V3D), "Should work with V3D input") self.assertTrue(isinstance(ol.qFromHKL([1, 1, 1]), V3D), "Should work with python array input") self.assertTrue(isinstance(ol.qFromHKL(np.array([1, 1, 1])), V3D), "Should work with numpy array input")
def test_qFromHKL(self): ol = OrientedLattice(1, 1, 1) hkl = V3D(1, 1, 1) qVec = ol.qFromHKL(hkl) self.assertAlmostEqual(hkl.X() * 2 * np.pi, qVec.X(), 9) self.assertAlmostEqual(hkl.Y() * 2 * np.pi, qVec.Y(), 9) self.assertAlmostEqual(hkl.Z() * 2 * np.pi, qVec.Z(), 9)
class Monochromator(): # only for PG __slots__ = ['lambdan', 'tth', 'en'] def __init__(self, reflect=[0, 0, 2], **kargs): self.kargs = kargs self.pgo = OrientedLattice(2.461, 2.461, 6.708, 90, 90, 60) self.q = self.pgo.qFromHKL(reflect).norm() if 'lambdan' in self.kargs.keys(): self.lambdan = self.kargs['lambdan'] self.en = (9.045 / self.lambdan)**2 self.k = 2 * math.pi / self.lambdan self.lambda2m2() if 'tth' in self.kargs.keys(): self.tth = abs(self.kargs['tth']) self.monolambda() if 'en' in self.kargs.keys(): self.en = self.kargs['en'] self.lambdan = 9.045 / (math.sqrt(self.en)) self.k = 2 * math.pi / self.lambdan self.lambda2m2() def lambda2m2(self): stth = self.q / 2.0 / self.k self.tth = math.asin(stth) * 360 / math.pi def monolambda(self): self.k = self.q / 2 / math.sin(self.tth * math.pi / 360) self.lambdan = 2 * math.pi / self.k self.en = (9.045 / self.lambdan)**2
def test_qFromHKL(self): ol = OrientedLattice(1,1,1) hkl = V3D(1,1,1) qVec = ol.qFromHKL(hkl) self.assertAlmostEqual(hkl.X() * 2 * np.pi, qVec.X(), 9) self.assertAlmostEqual(hkl.Y() * 2 * np.pi, qVec.Y(), 9) self.assertAlmostEqual(hkl.Z() * 2 * np.pi, qVec.Z(), 9)
class Scisoft(): def __init__(self, point): # input : qe # output : qe+tas self.point = point self.qe_para() self.qe_limit() if self.limit_qe == 1: self.scisoft() if tp.ModeChoice.mode == 3: # add sample stick rotation s0 self.scisoft_premium() self.tas = tl.TasLimit(self.tas).point else: self.tas = tl.TasLimit(self.tas).point else: self.tas = pd.Series(data=None, index=tp.TasStatus.tas_status.index.drop( ['mts', 'sta', 'dtx']).copy()) self.tas['s1s2_limit'] = 1 self.tas['soft_limit'] = 1 self.tas['qe_limit'] = self.limit_qe # raise Exception as def qe_para(self): self.orien = OrientedLattice(*Alignment.para) self.para = Alignment.para self.hkl = [self.point.h, self.point.k, self.point.l] self.len = self.orien.qFromHKL(self.hkl).norm() self.mono = Monochromator(en=self.point.ei) self.ana = Monochromator(en=self.point.ef) def qe_limit(self): if self.mono.k + self.ana.k < self.len: self.limit_qe = tp.LimitNumb.Modenumb[tp.LimitNumb.mode] else: self.limit_qe = 1 def angdif(self): # angle between point and refa p0 = self.hkl p1 = Alignment.refa p2 = Alignment.refb theta1 = self.orien.recAngle(p0[0], p0[1], p0[2], p1.h, p1.k, p1.l) valcos1 = math.cos(math.radians(theta1)) theta2 = self.orien.recAngle(p0[0], p0[1], p0[2], p2.h, p2.k, p2.l) valcos2 = math.cos(math.radians(theta2)) if valcos1 * valcos2 == 0: self.angdiff = theta1 * (valcos1 + valcos2) else: self.angdiff = theta1 * abs(valcos2) / valcos2 def scisoft(self): s2_value = (self.mono.k**2 + self.ana.k**2 - self.len**2) / 2.0 / self.mono.k / self.ana.k self.tth = math.degrees(math.acos(s2_value)) self.angdif() s2 = self.tth * tp.TasConfig.tas_config.s s1dif = (self.mono.k**2 - self.ana.k**2 + self.len**2) / 2.0 / self.mono.k / self.len s1dif = math.acos(s1dif) s1dif = s1dif * 180 / math.pi s1 = -1 * Alignment.delta - self.angdiff - s1dif * tp.TasConfig.tas_config.s index = ['m1', 'm2', 's1', 's2', 'a1', 'a2'] self.tas = pd.Series(data=[ self.mono.tth / 2, self.mono.tth, s1, s2, self.ana.tth / 2, self.ana.tth ], index=index) def s1p_split(self): # s0 first : magnet # s1 first : crystat s1p = self.tas.s1 delta_s1p = s1p - (tp.TasStatus.tas_status.s1 + tp.TasStatus.tas_status.s0) if tp.SplitMode.mode == 0: s0 = tp.TasStatus.tas_status.s0 + delta_s1p s1 = tp.TasStatus.tas_status.s1 elif tp.SplitMode.mode == 1: s1 = tp.TasStatus.tas_status.s1 + delta_s1p s0 = tp.TasStatus.tas_status.s0 return pd.Series(data=[s0, s1], index=['s0', 's1']) def scisoft_premium(self): junk = self.tas addition = self.s1p_split() junk.pop('s1') self.tas = junk.append(addition)
def runTest(self): # Na Mn Cl3 # R -3 H (148) # 6.592 6.592 18.585177 90 90 120 # UB/wavelength from /HFIR/HB3A/IPTS-25470/shared/autoreduce/HB3A_exp0769_scan0040.nxs ub = np.array([[1.20297e-01, 1.70416e-01, 1.43000e-04], [8.16000e-04, -8.16000e-04, 5.38040e-02], [1.27324e-01, -4.05110e-02, -4.81000e-04]]) wavelength = 1.553 # create fake MDEventWorkspace, similar to what is expected from exp769 after loading with HB3AAdjustSampleNorm MD_Q_sample = CreateMDWorkspace( Dimensions='3', Extents='-5,5,-5,5,-5,5', Names='Q_sample_x,Q_sample_y,Q_sample_z', Units='rlu,rlu,rlu', Frames='QSample,QSample,QSample') inst = LoadEmptyInstrument(InstrumentName='HB3A') AddTimeSeriesLog(inst, 'omega', '2010-01-01T00:00:00', 0.) AddTimeSeriesLog(inst, 'phi', '2010-01-01T00:00:00', 0.) AddTimeSeriesLog(inst, 'chi', '2010-01-01T00:00:00', 0.) MD_Q_sample.addExperimentInfo(inst) SetUB(MD_Q_sample, UB=ub) ol = OrientedLattice() ol.setUB(ub) sg = SpaceGroupFactory.createSpaceGroup("R -3") hkl = [] sat_hkl = [] for h in range(0, 6): for k in range(0, 6): for l in range(0, 11): if sg.isAllowedReflection([h, k, l]): if h == k == l == 0: continue q = V3D(h, k, l) q_sample = ol.qFromHKL(q) if not np.any(np.array(q_sample) > 5): hkl.append(q) FakeMDEventData( MD_Q_sample, PeakParams='1000,{},{},{},0.05'.format( *q_sample)) # satellite peaks at 0,0,+1.5 q = V3D(h, k, l + 1.5) q_sample = ol.qFromHKL(q) if not np.any(np.array(q_sample) > 5): sat_hkl.append(q) FakeMDEventData( MD_Q_sample, PeakParams='100,{},{},{},0.02'.format( *q_sample)) # satellite peaks at 0,0,-1.5 q = V3D(h, k, l - 1.5) q_sample = ol.qFromHKL(q) if not np.any(np.array(q_sample) > 5): sat_hkl.append(q) FakeMDEventData( MD_Q_sample, PeakParams='100,{},{},{},0.02'.format( *q_sample)) # Check that this fake workpsace gives us the expected UB peaks = FindPeaksMD(MD_Q_sample, PeakDistanceThreshold=1, OutputType='LeanElasticPeak') FindUBUsingFFT(peaks, MinD=5, MaxD=20) ShowPossibleCells(peaks) SelectCellOfType(peaks, CellType='Rhombohedral', Centering='R', Apply=True) OptimizeLatticeForCellType(peaks, CellType='Hexagonal', Apply=True) found_ol = peaks.sample().getOrientedLattice() self.assertAlmostEqual(found_ol.a(), 6.592, places=2) self.assertAlmostEqual(found_ol.b(), 6.592, places=2) self.assertAlmostEqual(found_ol.c(), 18.585177, places=2) self.assertAlmostEqual(found_ol.alpha(), 90) self.assertAlmostEqual(found_ol.beta(), 90) self.assertAlmostEqual(found_ol.gamma(), 120) # nuclear peaks predict = HB3APredictPeaks( MD_Q_sample, Wavelength=wavelength, ReflectionCondition='Rhombohedrally centred, obverse', SatellitePeaks=True, IncludeIntegerHKL=True) predict = HB3AIntegratePeaks(MD_Q_sample, predict, 0.25) self.assertEqual(predict.getNumberPeaks(), 66) # check that the found peaks are expected for n in range(predict.getNumberPeaks()): HKL = predict.getPeak(n).getHKL() self.assertTrue(HKL in hkl, msg=f"Peak {n} with HKL={HKL}") # magnetic peaks satellites = HB3APredictPeaks( MD_Q_sample, Wavelength=wavelength, ReflectionCondition='Rhombohedrally centred, obverse', SatellitePeaks=True, ModVector1='0,0,1.5', MaxOrder=1, IncludeIntegerHKL=False) satellites = HB3AIntegratePeaks(MD_Q_sample, satellites, 0.1) self.assertEqual(satellites.getNumberPeaks(), 80) # check that the found peaks are expected for n in range(satellites.getNumberPeaks()): HKL = satellites.getPeak(n).getHKL() self.assertTrue(HKL in sat_hkl, msg=f"Peak {n} with HKL={HKL}")
from mantid.simpleapi import * from mantid.geometry import OrientedLattice van = LoadNexus( '/HFIR/HB2C/IPTS-7776/shared/autoreduce/HB2C_{}.nxs'.format(6558)) LoadIsawUB('van', '/SNS/users/rwp/wand/single5/PNO_T.mat') ub = mtd['van'].sample().getOrientedLattice().getUB().copy() ol = OrientedLattice() ol.setUB(ub) q1 = ol.qFromHKL([1, 0, 0]) q2 = ol.qFromHKL([0, 1, 0]) q3 = ol.qFromHKL([0, 0, 1]) if 'data' in mtd: mtd.remove('data') if 'norm' in mtd: mtd.remove('norm') for run in range(4756, 6558, 1): print(run) md = LoadMD( Filename='/HFIR/HB2C/IPTS-7776/shared/autoreduce/HB2C_{}_MDE.nxs'. format(run)) mtd['van'].run().getGoniometer().setR( mtd['md'].getExperimentInfo(0).run().getGoniometer().getR()) #BinMD(InputWorkspace='md', OutputWorkspace='mdh', AlignedDim0='Q_sample_x,-10,10,401', AlignedDim1='Q_sample_y,-1,1,41', AlignedDim2='Q_sample_z,-10,10,401') BinMD(InputWorkspace='md', OutputWorkspace='mdh',