def mean_ia(inp,limit,only=None):
"""
Calculate the internal angle for each peak and store in inp.mena_ia[inp.no_grains][inp.nrefl[i]]
Jette Oddershede Januar 2009
"""
import build_fcn
build_fcn.FCN(inp)
import fcn
reload(fcn)
delete = 0
for i in range(inp.no_grains):
if i+1 in inp.fit['skip']:
pass
else:
rod = n.array([inp.rod[i][0]+inp.values['rodx%s' %i],inp.rod[i][1]+inp.values['rody%s' %i],inp.rod[i][2]+inp.values['rodz%s' %i]])
for j in range(inp.nrefl[i]-1,-1,-1):
Omega = tools.form_omega_mat_general(inp.w[inp.id[i][j]]*n.pi/180,inp.values['wx']*n.pi/180,inp.values['wy']*n.pi/180)
gexp = fcn.gexp(inp.w[inp.id[i][j]],inp.dety[inp.id[i][j]],inp.detz[inp.id[i][j]],
inp.values['wx'],inp.values['wy'],inp.values['tx'],inp.values['ty'],inp.values['tz'],
inp.values['py'],inp.values['pz'],inp.values['cy'],inp.values['cz'],inp.values['L'],
inp.values['x%s' %i],inp.values['y%s' %i],inp.values['z%s' %i])
gcalc = fcn.gcalc(inp.values['a'],inp.values['b'],inp.values['c'],inp.values['alpha'],inp.values['beta'],inp.values['gamma'],
inp.h[i][j],inp.k[i][j],inp.l[i][j],
rod[0],rod[1],rod[2],
inp.values['epsaa%s' %i],inp.values['epsab%s' %i],inp.values['epsac%s' %i],
inp.values['epsbb%s' %i],inp.values['epsbc%s' %i],inp.values['epscc%s' %i])
# gexp = n.dot(Omega,gexp)
# gcalc = n.dot(Omega,gcalc)
inp.mean_ia[i][j] = IA(n.transpose(gexp)[0],n.transpose(gcalc)[0])
# print i+1,inp.mean_ia[i][j]
if inp.mean_ia[i][j] > limit:
delete = delete + 1
reject(inp,i,j,'ia')
if only != []:
print 'Rejected', delete, 'reflection based on internal angles'
insignificant(inp)
def test_find_omega_general_nowedge(self):
# generate random gvector
hkl = n.array([
round(n.random.rand() * 10 - 5),
round(n.random.rand() * 10 - 5),
round(n.random.rand() * 10 - 5)
])
ucell = n.array([
3.5 + n.random.rand(), 3.5 + n.random.rand(),
3.5 + n.random.rand(), 89.5 + n.random.rand(),
89.5 + n.random.rand(), 89.5 + n.random.rand()
])
B = tools.form_b_mat(ucell)
U = tools.euler_to_u(n.random.rand() * 2. * n.pi,
n.random.rand() * 2. * n.pi,
n.random.rand() * n.pi)
wavelength = 0.95 + n.random.rand() * 0.1
gvec = n.dot(U, n.dot(B, hkl))
tth = tools.tth(ucell, hkl, wavelength)
# calculate corresponding eta and Omega using tools.find_omega_general
(omega1,
eta1) = tools.find_omega_general(gvec * wavelength / (4. * n.pi), tth,
0, 0)
Om1 = []
for i in range(len(omega1)):
Om1.append(tools.form_omega_mat_general(omega1[i], 0, 0))
# calculate corresponding eta and Omega using tools.find_omega_wedge
omega2 = tools.find_omega(gvec, tth)
Om2 = []
for i in range(len(omega2)):
Om2.append(tools.form_omega_mat(omega2[i]))
#assert
for i in range(len(omega1)):
# print Om1[i]
# print Om2[i]
diff = n.abs(Om1[i] - Om2[i]).sum()
self.assertAlmostEqual(diff, 0, 9)
def intensity(inp):
"""
Reject peaks based on intensity
Jette Oddershede, August 27 2008
Absorption correction added December 2011
"""
if inp.files['structure_file'] != None:
inp.param['structure_phase_0'] = inp.files['structure_file']
xtal_structure = reflections.open_structure(inp.param,0)
hkl = reflections.gen_miller(inp.param,0)
hkl = reflections.calc_intensity(hkl,xtal_structure)
# print hkl
if inp.fit['abs_mu'] > 0:
xmin = min(inp.fit['abs_xlim'])*1e3
xmax = max(inp.fit['abs_xlim'])*1e3
ymin = min(inp.fit['abs_ylim'])*1e3
ymax = max(inp.fit['abs_ylim'])*1e3
for i in range(inp.no_grains):
x = deepcopy(inp.values['x%s' %i])
y = deepcopy(inp.values['y%s' %i])
z = deepcopy(inp.values['z%s' %i])
#Make sure that grain not outside of bounds for doing the correction
if inp.fit['abs_mu'] > 0:
if x < xmin:
x = xmin
elif x > xmax:
x = xmax
if y < ymin:
y = ymin
elif y > ymax:
y = ymax
for j in range(inp.nrefl[i]):
h = inp.h[i][j]
k = inp.k[i][j]
l = inp.l[i][j]
# Absorption correction start
if inp.fit['abs_mu'] > 0:
w = inp.w[inp.id[i][j]]
dety = inp.dety[inp.id[i][j]]
detz = inp.detz[inp.id[i][j]]
Omega = tools.form_omega_mat_general(w*n.pi/180.,inp.values['wx']*n.pi/180.,inp.values['wy']*n.pi/180.)
R = tools.detect_tilt(inp.values['tx'],inp.values['ty'],inp.values['tz'])
d_out = n.dot(R,n.array([[0],
[(dety-inp.values['cy'])*inp.values['py']],
[(detz-inp.values['cz'])*inp.values['pz']]]))
d_out = d_out + n.array([[inp.values['L']],[0],[0]]) - n.dot(Omega,n.array([[x],[y],[z]]))
d_out = n.dot(n.transpose(Omega),d_out/n.sqrt(n.sum(d_out**2)))
d_in = n.dot(n.transpose(Omega),n.array([[-1],[0],[0]])) #from grain to source!
# distance to bounding planes assuming d_in and d_out unit vectors
xdist_in = 1e6
xdist_out = 1e6
ydist_in = 1e6
ydist_out = 1e6
if d_in[0] < 0:
xdist_in = (x-xmin)/abs(d_in[0,0])
elif d_in[0] > 0:
xdist_in = (xmax-x)/abs(d_in[0,0])
if d_in[1] < 0:
ydist_in = (y-ymin)/abs(d_in[1,0])
elif d_in[1] > 0:
ydist_in = (ymax-y)/abs(d_in[1,0])
dist_in = min(xdist_in,ydist_in)
if d_out[0] < 0:
xdist_out = (x-xmin)/abs(d_out[0,0])
elif d_out[0] > 0:
xdist_out = (xmax-x)/abs(d_out[0,0])
if d_out[1] < 0:
ydist_out = (y-ymin)/abs(d_out[1,0])
elif d_out[1] > 0:
ydist_out = (ymax-y)/abs(d_out[1,0])
dist_out = min(xdist_out,ydist_out)
dist = dist_in + dist_out
# abs_mu in mm-1 and dist in microns
exponential = n.exp(inp.fit['abs_mu']*dist*1e-3)
#print h,k,l,w,x,y,z,dist_in*1e-3,dist_out*1e-3,dist*1e-3,exponential
else:
exponential = 1.
# Absorption correction end
value = False
for m in range(len(hkl)):
if hkl[m][0] == h and hkl[m][1] == k and hkl[m][2] == l:
inp.volume[i][j] = inp.F2vol[inp.id[i][j]]/hkl[m][3]*exponential
value = True
break
else:
pass
if value == False:
# print i+1,j+1,h,k,l,'should never go here, ask osho for help...'
inp.volume[i][j] = -1
data = deepcopy(inp.volume)
minvol = []
maxvol = []
for i in range(inp.no_grains):
if i+1 in inp.fit['skip']:
pass
else:
rej = []
newreject = 1
while newreject > 0:
tmp = len(rej)
mad(data[i],rej,inp.fit['rej_vol'])
newreject = len(rej) - tmp
avgdata = n.sum(data[i])/len(data[i])
sigdata = spread(data[i])
if len(rej) > 1:
avgrej = n.sum(rej)/len(rej)
sigrej = spread(rej)
elif len(rej) == 1:
avgrej = rej[0]
sigrej = 0
else:
avgrej = 0
sigrej = 0
if len(data[i]) > 0:
minvol.append(max(0,min(data[i])))
maxvol.append(max(data[i]))
else:
minvol.append(0)
maxvol.append(-1)
if i+1 not in inp.fit['skip']:
inp.fit['skip'].append(i+1)
# print '\n',i, avgdata, sigdata, len(data[i]), minvol[i], maxvol[i],'\n ',avgrej, sigrej, len(reject)#,'\n',data[i],'\n',reject
delete = 0
for i in range(inp.no_grains):
if i+1 in inp.fit['skip']:
pass
else:
for j in range(inp.nrefl[i]-1,-1,-1):
if inp.volume[i][j] < minvol[i] or inp.volume[i][j] > maxvol[i]:
reject(inp,i,j,'intensity')
delete = delete + 1
print 'Rejected', delete, 'peaks because of different intensity scales'
insignificant(inp)
def mean_ia_old(inp,limit,only=None):
"""
Calculate the internal angle for each peak and store in inp.mena_ia[inp.no_grains][inp.nrefl[i]]
Jette Oddershede Januar 2009
"""
import build_fcn
build_fcn.FCN(inp)
import fcn
reload(fcn)
for i in range(inp.no_grains):
if i+1 in inp.fit['skip']:
pass
else:
rod = n.array([inp.rod[i][0]+inp.values['rodx%s' %i],inp.rod[i][1]+inp.values['rody%s' %i],inp.rod[i][2]+inp.values['rodz%s' %i]])
for j in range(inp.nrefl[i]):
Omega = tools.form_omega_mat_general(inp.w[inp.id[i][j]]*n.pi/180,inp.values['wx']*n.pi/180,inp.values['wy']*n.pi/180)
gexp = fcn.gexp(inp.w[inp.id[i][j]],inp.dety[inp.id[i][j]],inp.detz[inp.id[i][j]],
inp.values['wx'],inp.values['wy'],inp.values['tx'],inp.values['ty'],inp.values['tz'],
inp.values['py'],inp.values['pz'],inp.values['cy'],inp.values['cz'],inp.values['L'],
inp.values['x%s' %i],inp.values['y%s' %i],inp.values['z%s' %i])
gcalc = fcn.gcalc(inp.values['a'],inp.values['b'],inp.values['c'],inp.values['alpha'],inp.values['beta'],inp.values['gamma'],
inp.h[i][j],inp.k[i][j],inp.l[i][j],
rod[0],rod[1],rod[2],
inp.values['epsaa%s' %i],inp.values['epsab%s' %i],inp.values['epsac%s' %i],
inp.values['epsbb%s' %i],inp.values['epsbc%s' %i],inp.values['epscc%s' %i])
gexp = n.dot(Omega,gexp)
gcalc = n.dot(Omega,gcalc)
# print int(inp.h[i][j]), int(inp.k[i][j]), int(inp.l[i][j]),inp.w[inp.id[i][j]],inp.dety[inp.id[i][j]],inp.detz[inp.id[i][j]],'gexp', 2*n.pi*n.transpose(gexp)[0]/inp.param['wavelength']
# print int(inp.h[i][j]), int(inp.k[i][j]), int(inp.l[i][j]),inp.w[inp.id[i][j]],inp.dety[inp.id[i][j]],inp.detz[inp.id[i][j]],'gcalc', 2*n.pi*n.transpose(gcalc)[0]/inp.param['wavelength']
inp.mean_ia[i][j] = IA(n.transpose(gexp)[0],n.transpose(gcalc)[0])
# inp.mean_ia[i][j] = IAforrod(n.transpose(gexp)[0],n.transpose(gcalc)[0],rod)
# print inp.h[i][j], inp.k[i][j], inp.l[i][j], inp.id[i][j], inp.mean_ia[i][j]
data = deepcopy(inp.mean_ia)
maxia = [0]*inp.no_grains
for i in range(inp.no_grains):
data[i].sort()
if i+1 in inp.fit['skip']:
pass
else:
mean = n.sum(data[i])/len(data[i])
medi = median(data[i])
# print i, len(data[i]), medi, mean,'\n',data[i]
while mean > limit*medi:
data[i].pop()
mean = n.sum(data[i])/inp.nrefl[i]
medi = median(data[i])
maxia[i] = max(data[i])
# print i, len(data[i]),medi,mean,'\n',data[i],'\n'
delete = 0
if only==None:
only = range(1,1+inp.no_grains)
for i in range(inp.no_grains):
if i+1 in inp.fit['skip'] or i+1 not in only:
pass
else:
for j in range(inp.nrefl[i]-1,-1,-1): # loop backwards to make pop work
if inp.mean_ia[i][j] > maxia[i]:
delete = delete + 1
reject(inp,i,j,'ia')
if only != []:
print 'Rejected', delete, 'reflection based on internal angles'
insignificant(inp)
def make_image(self, frame_number=None):
"""
makeimage script produces edf diffraction images using the reflection information
Henning Osholm Sorensen, June 23, 2006.
python translation Jette Oddershede, March 31, 2008
"""
peakshape = self.graindata.param['peakshape']
if peakshape[0] == 0: # spike peak, 2x2 pixels
peak_add = 1
frame_add = 1
peakwsig = 0
elif peakshape[0] == 1: # 3d Gaussian peak
peak_add = max(1, int(round(peakshape[1])))
frame_add = max(1, int(round(peakshape[1])))
peakwsig = peakshape[2]
elif peakshape[0] == 3: # 3d Gaussian peak in 2theta,eta,omega
peak_add = 1
frame_add = 1
cen_tth = int(1.5 * peakshape[1] / Delta_tth)
frame_tth = 2 * cen_tth + 1
fwhm_tth = peakshape[1] / Delta_tth
cen_eta = int(1.5 * peakshape[2] / Delta_eta)
frame_eta = 2 * cen_eta + 1
fwhm_eta = peakshape[2] / Delta_eta
raw_tth_eta = n.zeros((frame_tth, frame_eta))
raw_tth_eta[cen_tth, cen_eta] = 1
filter_tth_eta = ndimage.gaussian_filter(
raw_tth_eta, [0.5 * fwhm_tth, 0.5 * fwhm_eta])
peakwsig = 1.
framedimy = int(self.graindata.param['dety_size'] + 2 * frame_add)
framedimz = int(self.graindata.param['detz_size'] + 2 * frame_add)
totalrefl = 0
if frame_number == None:
no_frames = list(range(len(self.graindata.frameinfo)))
print('Generating diffraction images')
else:
no_frames = [frame_number]
for i in no_frames:
check_input.interrupt(self.killfile)
t1 = time.clock()
nrefl = 0
frame = n.zeros((framedimy, framedimz))
omega = self.graindata.frameinfo[i].omega
omega_step = self.graindata.param['omega_step']
# Jettes hack to add relative movement of sample and detector, modelled to be Gaussian in y and z direction with a spread of 1 micron
# movement of 1 micron along x judged to be irrelevant, at least for farfield data
y_move = n.random.normal(0, 1. / self.graindata.param['dety_size'])
z_move = n.random.normal(0, 1. / self.graindata.param['detz_size'])
# loop over grains
for j in range(self.graindata.param['no_grains']):
# loop over reflections for each grain
gr_pos = n.array(self.graindata.param['pos_grains_%s' % j])
for k in range(len(self.graindata.grain[j].refs)):
# exploit that the reflection list is sorted according to omega
if self.graindata.grain[j].refs[k,A_id['omega']]*180/n.pi > \
omega+omega_step+2*peakwsig:
break
elif self.graindata.grain[j].refs[k,A_id['omega']]*180/n.pi < \
omega-2*peakwsig:
continue
dety = self.graindata.grain[j].refs[
k, A_id['detyd']] # must be spot position after
detz = self.graindata.grain[j].refs[
k, A_id['detzd']] # applying spatial distortion
#apply hack
# dety = self.graindata.grain[j].refs[k,A_id['dety']] + y_move
# detz = self.graindata.grain[j].refs[k,A_id['detz']] + z_move
ndety = int(round(dety))
ndetz = int(round(detz))
yrange = list(
range(ndety + frame_add - peak_add,
ndety + frame_add + peak_add + 1))
zrange = list(
range(ndetz + frame_add - peak_add,
ndetz + frame_add + peak_add + 1))
intensity = int(
round(self.graindata.grain[j].refs[k, A_id['Int']]))
nrefl = nrefl + 1
totalrefl = totalrefl + 1
# Gaussian along omega
if peakshape[0] == 1 or peakshape[0] == 3:
fraction = norm.cdf((omega-self.graindata.grain[j].refs[k,A_id['omega']]*180/n.pi+omega_step)/(0.5*peakwsig))\
-norm.cdf((omega-self.graindata.grain[j].refs[k,A_id['omega']]*180/n.pi)/(0.5*peakwsig))
else:
fraction = 1.
if peakshape[0] == 3:
# Gaussian peaks along 2theta,eta
tth = self.graindata.grain[j].refs[k, A_id['tth']]
eta = self.graindata.grain[j].refs[k, A_id['eta']]
Om = tools.form_omega_mat_general(
self.graindata.grain[j].refs[k, A_id['omega']], 0,
-1. * self.graindata.param['wedge'] * n.pi / 180.)
[tx, ty, tz] = n.dot(Om, gr_pos)
for t in range(frame_tth):
tth_present = tth + (
t - cen_tth) * Delta_tth * n.pi / 180.
for e in range(frame_eta):
eta_present = eta + (
e - cen_eta) * Delta_eta * n.pi / 180.
[dety_present,
detz_present] = detector.det_coor2(
tth_present,
eta_present,
self.graindata.param['distance'],
self.graindata.param['y_size'],
self.graindata.param['z_size'],
self.graindata.param['dety_center'],
self.graindata.param['detz_center'],
self.graindata.R,
tx,
ty,
tz,
)
if self.graindata.param['spatial'] != None:
from ImageD11 import blobcorrector
self.spatial = blobcorrector.correctorclass(
self.graindata.param['spatial'])
# To match the coordinate system of the spline file
# SPLINE(i,j): i = detz; j = (dety_size-1)-dety
# Well at least if the spline file is for frelon2k
(x, y) = detector.detyz_to_xy(
[dety_present, detz_present],
self.graindata.param['o11'],
self.graindata.param['o12'],
self.graindata.param['o21'],
self.graindata.param['o22'],
self.graindata.param['dety_size'],
self.graindata.param['detz_size'])
# Do the spatial distortion
(xd, yd) = self.spatial.distort(x, y)
# transform coordinates back to dety,detz
(dety_present,
detz_present) = detector.xy_to_detyz(
[xd, yd], self.graindata.param['o11'],
self.graindata.param['o12'],
self.graindata.param['o21'],
self.graindata.param['o22'],
self.graindata.param['dety_size'],
self.graindata.param['detz_size'])
y = int(round(dety_present))
z = int(round(detz_present))
try:
frame[y + frame_add, z + frame_add] = frame[
y + frame_add, z +
frame_add] + fraction * intensity * filter_tth_eta[
t, e]
except:
# FIXME print("Unhandled exception in make_image.py")
pass
else:
# Generate spikes, 2x2 pixels
for y in yrange:
for z in zrange:
if y > 0 and y < framedimy and z > 0 and z < framedimz and abs(
dety + frame_add - y) < 1 and abs(
detz + frame_add - z) < 1:
# frame[y-1,z] = frame[y-1,z] + fraction*intensity*(1-abs(dety+frame_add-y))*(1-abs(detz+frame_add-z))
y = int(round(y))
z = int(round(z))
frame[y, z] = frame[
y, z] + fraction * intensity * (
1 - abs(dety + frame_add - y)) * (
1 - abs(detz + frame_add - z))
# 2D Gaussian on detector
if peakshape[0] == 1:
frame = ndimage.gaussian_filter(frame, peakshape[1] * 0.5)
# add background
if self.graindata.param['bg'] > 0:
frame = frame + self.graindata.param['bg'] * n.ones(
(framedimy, framedimz))
# add noise
if self.graindata.param['noise'] != 0:
frame = n.random.poisson(frame)
# apply psf
if self.graindata.param['psf'] != 0:
frame = ndimage.gaussian_filter(
frame, self.graindata.param['psf'] * 0.5)
# resize, convert to integers and flip to same orientation as experimental frames
frame = frame[frame_add:framedimy - frame_add,
frame_add:framedimz - frame_add]
# limit values above 16 bit to be 16bit
frame = n.clip(frame, 0, 2**16 - 1)
# convert to integers
frame = n.uint16(frame)
#flip detector orientation according to input: o11, o12, o21, o22
frame = detector.trans_orientation(frame,
self.graindata.param['o11'],
self.graindata.param['o12'],
self.graindata.param['o21'],
self.graindata.param['o22'],
'inverse')
# Output frames
if '.edf' in self.graindata.param['output']:
self.write_edf(i, frame)
if '.edf.gz' in self.graindata.param['output']:
self.write_edf(i, frame, usegzip=True)
if '.tif' in self.graindata.param['output']:
self.write_tif(i, frame)
if '.tif16bit' in self.graindata.param['output']:
self.write_tif16bit(i, frame)
print('\rDone frame %i took %8f s' % (i + 1, time.clock() - t1),
end=' ')
sys.stdout.flush()
def make_image(self, grainno=None, refl=None):
from scipy import ndimage
if grainno == None:
do_grains = list(range(self.graindata.param['no_grains']))
else:
do_grains = [grainno]
# loop over grains
for grainno in do_grains:
gr_pos = n.array(self.graindata.param['pos_grains_%s' \
%(self.graindata.param['grain_list'][grainno])])
B = self.graindata.grain[grainno].B
SU = n.dot(self.graindata.S, self.graindata.grain[grainno].U)
if refl == None:
do_refs = list(range(len(self.graindata.grain[grainno].refs)))
else:
do_refs = [refl]
# loop over reflections for each grain
for nref in do_refs:
# exploit that the reflection list is sorted according to omega
print('\rDoing reflection %i of %i for grain %i of %i' %
(nref + 1, len(self.graindata.grain[grainno].refs),
grainno + 1, self.graindata.param['no_grains']),
end=' ')
sys.stdout.flush()
#print 'Doing reflection: %i' %nref
if self.graindata.param['odf_type'] == 3:
intensity = 1
else:
intensity = self.graindata.grain[grainno].refs[nref,
A_id['Int']]
hkl = n.array([
self.graindata.grain[grainno].refs[nref, A_id['h']],
self.graindata.grain[grainno].refs[nref, A_id['k']],
self.graindata.grain[grainno].refs[nref, A_id['l']]
])
Gc = n.dot(B, hkl)
for i in range(self.odf.shape[0]):
for j in range(self.odf.shape[1]):
for k in range(self.odf.shape[2]):
check_input.interrupt(self.killfile)
if self.odf[i, j, k] > self.odf_cut:
Gtmp = n.dot(self.Uodf[i, j, k], Gc)
Gw = n.dot(SU, Gtmp)
Glen = n.sqrt(n.dot(Gw, Gw))
tth = 2 * n.arcsin(Glen /
(2 * abs(self.graindata.K)))
costth = n.cos(tth)
Qw = Gw * self.graindata.param[
'wavelength'] / (4. * n.pi)
(Omega, eta) = tools.find_omega_general(
Qw, tth, self.wx, self.wy)
try:
minpos = n.argmin(
n.abs(Omega -
self.graindata.grain[grainno].
refs[nref, A_id['omega']]))
except:
print(Omega)
if len(Omega) == 0:
continue
omega = Omega[minpos]
# if omega not in rotation range continue to next step
if (self.graindata.param['omega_start']*n.pi/180) > omega or\
omega > (self.graindata.param['omega_end']*n.pi/180):
continue
Om = tools.form_omega_mat_general(
omega, self.wx, self.wy)
Gt = n.dot(Om, Gw)
# Calc crystal position at present omega
[tx, ty, tz] = n.dot(Om, gr_pos)
(dety, detz) = detector.det_coor(
Gt, costth,
self.graindata.param['wavelength'],
self.graindata.param['distance'],
self.graindata.param['y_size'],
self.graindata.param['z_size'],
self.graindata.param['dety_center'],
self.graindata.param['detz_center'],
self.graindata.R, tx, ty, tz)
if self.graindata.param['spatial'] != None:
# To match the coordinate system of the spline file
# SPLINE(i,j): i = detz; j = (dety_size-1)-dety
# Well at least if the spline file is for frelon2k
(x, y) = detector.detyz_to_xy(
[dety, detz],
self.graindata.param['o11'],
self.graindata.param['o12'],
self.graindata.param['o21'],
self.graindata.param['o22'],
self.graindata.param['dety_size'],
self.graindata.param['detz_size'])
# Do the spatial distortion
(xd, yd) = self.spatial.distort(x, y)
# transform coordinates back to dety,detz
(dety, detz) = detector.xy_to_detyz(
[xd, yd], self.graindata.param['o11'],
self.graindata.param['o12'],
self.graindata.param['o21'],
self.graindata.param['o22'],
self.graindata.param['dety_size'],
self.graindata.param['detz_size'])
if dety > -0.5 and dety <= self.graindata.param['dety_size']-0.5 and\
detz > -0.5 and detz <= self.graindata.param['detz_size']-0.5:
dety = int(round(dety))
detz = int(round(detz))
frame_no = int(n.floor((omega*180/n.pi-self.graindata.param['omega_start'])/\
self.graindata.param['omega_step']))
self.frames[frame_no][
dety, detz] = self.frames[frame_no][
dety,
detz] + intensity * self.odf[i, j,
k]
def find_refl(inp):
"""
From U, (x,y,z) and B determined for the far-field case
calculate the possible reflection on the near-field detector
output[grainno][reflno]=[h,k,l,omega,dety,detz,tth,eta]
"""
S = n.array([[1, 0, 0],[0, 1, 0],[0, 0, 1]])
R = tools.detect_tilt(inp.param['tilt_x'],
inp.param['tilt_y'],
inp.param['tilt_z'])
inp.possible = []
# if structure info is given use this
if inp.files['structure_file'] != None:
inp.param['structure_phase_0'] = inp.files['structure_file']
xtal_structure = reflections.open_structure(inp.param,0)
HKL = reflections.gen_miller(inp.param,0)
else:
inp.param['unit_cell_phase_0'] = inp.unit_cell
inp.param['sgno_phase_0'] = inp.fit['sgno']
HKL = reflections.gen_miller(inp.param,0)
for grainno in range(inp.no_grains):
inp.possible.append([])
if grainno+1 not in inp.fit['skip']:
B = tools.epsilon_to_b(n.array([inp.values['epsaa%s' %grainno],
inp.values['epsab%s' %grainno],
inp.values['epsac%s' %grainno],
inp.values['epsbb%s' %grainno],
inp.values['epsbc%s' %grainno],
inp.values['epscc%s' %grainno]]),
inp.unit_cell)
U = tools.rod_to_u([inp.rod[grainno][0]+inp.values['rodx%s' %grainno],
inp.rod[grainno][1]+inp.values['rody%s' %grainno],
inp.rod[grainno][2]+inp.values['rodz%s' %grainno]])
gr_pos = n.array([inp.values['x%s' %grainno],
inp.values['y%s' %grainno],
inp.values['z%s' %grainno]])
for hkl in HKL:
Gc = n.dot(B,hkl[0:3])
Gw = n.dot(S,n.dot(U,Gc))
tth = tools.tth2(Gw,inp.param['wavelength'])
# print hkl[0:3],tth*180./n.pi
costth = n.cos(tth)
(Omega, Eta) = tools.find_omega_general(inp.param['wavelength']/(4.*n.pi)*Gw,
tth,
inp.values['wx']*n.pi/180,
inp.values['wy']*n.pi/180)
if len(Omega) > 0:
for solution in range(len(Omega)):
omega = Omega[solution]
eta = Eta[solution]
for i in range(len(inp.fit['w_limit'])//2):
if (inp.fit['w_limit'][2*i]*n.pi/180) < omega and\
omega < (inp.fit['w_limit'][2*i+1]*n.pi/180):
# form Omega rotation matrix
Om = tools.form_omega_mat_general(omega,inp.values['wx']*n.pi/180,inp.values['wy']*n.pi/180)
Gt = n.dot(Om,Gw)
# Calc crystal position at present omega
[tx,ty,tz]= n.dot(Om,gr_pos)
# Calc detector coordinate for peak
(dety, detz) = detector.det_coor(Gt,costth,
inp.param['wavelength'],
inp.param['distance'],
inp.param['y_size'],
inp.param['z_size'],
inp.param['y_center'],
inp.param['z_center'],
R,tx,ty,tz)
#If peak within detector frame store it in possible
if (-0.5 < dety) and\
(dety < inp.fit['dety_size']-0.5) and\
(-0.5 < detz) and\
(detz < inp.fit['detz_size']-0.5):
inp.possible[grainno].append([hkl[0],
hkl[1],
hkl[2],
omega*180/n.pi,
dety,
detz,
tth,
eta])
def run(self):
spot_id = 0
# Generate orientations of the grains and loop over all grains
print('no of grains ', self.param['no_grains'])
for grainno in range(self.param['no_grains']):
A = []
U = self.param['U_grains_%s' % (self.param['grain_list'][grainno])]
if len(self.param['phase_list']) == 1:
phase = self.param['phase_list'][0]
else:
phase = self.param['phase_grains_%s' %
(self.param['grain_list'][grainno])]
unit_cell = self.param['unit_cell_phase_%i' % phase]
self.grain.append(variables.grain_cont(U))
gr_pos = n.array(self.param['pos_grains_%s' %
(self.param['grain_list'][grainno])])
gr_eps = n.array(self.param['eps_grains_%s' %
(self.param['grain_list'][grainno])])
# Calculate the B-matrix based on the strain tensor for each grain
B = tools.epsilon_to_b(gr_eps, unit_cell)
# add B matrix to grain container
self.grain[grainno].B = B
V = tools.cell_volume(unit_cell)
grain_vol = n.pi / 6 * self.param[
'size_grains_%s' % self.param['grain_list'][grainno]]**3
# print 'GRAIN NO: ',self.param['grain_list'][grainno]
# print 'GRAIN POSITION of grain ',self.param['grain_list'][grainno],': ',gr_pos
# print 'STRAIN TENSOR COMPONENTS (e11 e12 e13 e22 e23 e33) of grain ',self.param['grain_list'][grainno],':\n',gr_eps
# print 'U of grain ',self.param['grain_list'][grainno],':\n',U
nrefl = 0
# Calculate these values:
# totalnr, grainno, refno, hkl, omega, 2theta, eta, dety, detz
# For all reflections in Ahkl that fulfill omega_start < omega < omega_end.
# All angles in Grain are in degrees
for hkl in self.hkl[self.param['phase_list'].index(phase)]:
check_input.interrupt(self.killfile)
Gc = n.dot(B, hkl[0:3])
Gw = n.dot(self.S, n.dot(U, Gc))
tth = tools.tth2(Gw, self.param['wavelength'])
costth = n.cos(tth)
(Omega, Eta) = tools.find_omega_general(
Gw * self.param['wavelength'] / (4. * n.pi), tth, self.wx,
self.wy)
if len(Omega) > 0:
for solution in range(len(Omega)):
omega = Omega[solution]
eta = Eta[solution]
if (self.param['omega_start']*n.pi/180) < omega and\
omega < (self.param['omega_end']*n.pi/180):
# form Omega rotation matrix
Om = tools.form_omega_mat_general(
omega, self.wx, self.wy)
Gt = n.dot(Om, Gw)
# Calc crystal position at present omega and continue if this is outside the illuminated volume
[tx, ty, tz] = n.dot(Om, gr_pos)
if self.param['beam_width'] != None:
if n.abs(ty) > self.param['beam_width'] / 2.:
continue
# Calc detector coordinate for peak
(dety, detz) = detector.det_coor(
Gt, costth, self.param['wavelength'],
self.param['distance'], self.param['y_size'],
self.param['z_size'],
self.param['dety_center'],
self.param['detz_center'], self.R, tx, ty, tz)
#If shoebox extends outside detector exclude it
if (-0.5 > dety) or\
(dety > self.param['dety_size']-0.5) or\
(-0.5 > detz) or\
(detz > self.param['detz_size']-0.5):
continue
if self.param['spatial'] != None:
# To match the coordinate system of the spline file
(x, y) = detector.detyz_to_xy(
[dety, detz], self.param['o11'],
self.param['o12'], self.param['o21'],
self.param['o22'], self.param['dety_size'],
self.param['detz_size'])
# Do the spatial distortion
(xd, yd) = self.spatial.distort(x, y)
# transform coordinates back to dety,detz
(detyd, detzd) = detector.xy_to_detyz(
[xd, yd], self.param['o11'],
self.param['o12'], self.param['o21'],
self.param['o22'], self.param['dety_size'],
self.param['detz_size'])
else:
detyd = dety
detzd = detz
if self.param['beampol_apply'] == 1:
#Polarization factor (Kahn, J. Appl. Cryst. (1982) 15, 330-337.)
rho = n.pi / 2.0 + eta + self.param[
'beampol_direct'] * n.pi / 180.0
P = 0.5 * (1 + costth*costth -\
self.param['beampol_factor']*n.cos(2*rho)*n.sin(tth)**2)
else:
P = 1.0
#Lorentz factor
if self.param['lorentz_apply'] == 1:
if eta != 0:
L = 1 / (n.sin(tth) * abs(n.sin(eta)))
else:
L = n.inf
else:
L = 1.0
overlaps = 0 # set the number overlaps to zero
if self.param['intensity_const'] != 1:
intensity = int_intensity(
hkl[3], L, P, self.param['beamflux'],
self.param['wavelength'], V, grain_vol)
else:
intensity = hkl[3]
A.append([
self.param['grain_list'][grainno], nrefl,
spot_id, hkl[0], hkl[1], hkl[2], tth, omega,
eta, dety, detz, detyd, detzd, Gw[0], Gw[1],
Gw[2], L, P, hkl[3], intensity, overlaps
])
nrefl = nrefl + 1
spot_id = spot_id + 1
# print 'Length of Grain', len(self.grain[0].refl)
A = n.array(A)
if len(A) > 0:
# sort rows according to omega
A = A[n.argsort(A, 0)[:, A_id['omega']], :]
# Renumber the reflections
A[:, A_id['ref_id']] = n.arange(nrefl)
# Renumber the spot_id
A[:,
A_id['spot_id']] = n.arange(n.min(A[:, A_id['spot_id']]),
n.max(A[:, A_id['spot_id']]) + 1)
else:
A = n.zeros((0, len(A_id)))
# save reflection info in grain container
self.grain[grainno].refs = A
print('\rDone %3i grain(s) of %3i' %
(grainno + 1, self.param['no_grains']),
end=' ')
sys.stdout.flush()
print('\n')
