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',
