def ReMap_Base(self,map_func,**kwargs):
"""kwargs must contain dx = ,dy = ,dz = """
dx = kwargs['dx']; dy = kwargs['dy']; dz = kwargs['dz']
del kwargs['dx']; del kwargs['dy']; del kwargs['dz']
self.dx = dx; self.dy = dy; self.dz = dz
raw_data = self.raw_data.Copy()
xyzdict = self.xyzdict.Copy()
self.raw_data = inv_dict()
self.xyzdict = inv_dict()
temp = inv_dict()
for key in raw_data.keys():
vector = raw_data[key]
new_vec = map_func(vector,**kwargs)
self.Add(new_vec,key)
def Get_Pixel_From_Recip_Vector(v,center_px,procession,L0,lam=1.,tol=10**-3,mm_per_px = .2):
sols = Get_Pixel_Polar_Coords(v,lam,tol)
tmp_center = Pixel(center_px)
tmp = Pixel((0,0))
row0,col0 = center_px
center_pos = (row0*(-e3func())+col0*(-e2func()))*mm_per_px + L0*e1func()
final_pxs = inv_dict()
for key in sols.keys():
w,a,b = sols[key]
#eta,theta = alphabeta_polar_to_etatheta(a,b)
R = Rodrigues3(e3func(),w)
G_pos = dot(R,procession)
proc_x = dot(G_pos,e1func())
L_act = L0 - proc_x
s = Construct_s_s0_Polar_Coords(a,b)+e1func()
#or, s = erhofunc(b,a,p=e3func(),q=e1func(),r=e2func()) = erhofunc(b,a)
Hyp = L_act/dot(s,e1func())
r_act = G_pos + Hyp*s
Proj = Proj_func(e1func())
rel_pixel_pos = r_act/mm_per_px
Pr = dot(Proj,rel_pixel_pos)
x_rel_pos = dot(Pr,-e2func())
y_rel_pos = dot(Pr,e3func())
loc = tmp.from_x_y((x_rel_pos,y_rel_pos),origin = tmp_center.pos)
prow,pcol = tmp.to_row_col(loc)
final_pxs.Add(key,Pixel((prow,pcol)))
return final_pxs
def __init__(self,dx,dy,dz,b1 = e1func(),b2 = e2func(),b3 = e3func(),base_map = Get_Cartesian, inv_base_map = From_Cartesian):
self.base_map = base_map
self.inv_base_map = inv_base_map
self.raw_data = inv_dict()
self.b1 = b1
self.b2 = b2
self.b3 = b3
self.xyzdict = inv_dict()
self.dx = dx
self.dy = dy
self.dz = dz
self.raw_data = inv_dict()
self.core_kwargs = {}
self.core_kwargs['b1']=b1
self.core_kwargs['b2']=b2
self.core_kwargs['b3']=b3
self.allow_unique = False
def ReMap(self,map_func,**kwargs):
"""kwargs must contain dx = ,dy = ,dz = """
da1 = kwargs['da1']; da2 = kwargs['da2']; da3 = kwargs['da3']
del kwargs['da1']; del kwargs['da2']; del kwargs['da3']
self.da1 = da1; self.da2 = da2; self.da3 = da3
raw_data = self.raw_data
temp = inv_dict()
kwargs = self.kwargs
for key in raw_data.keys():
vector = raw_data[key]
new_vec = map_func(vector,**kwargs)
self.Add(new_vec,key)
def Compute_Coords_From_Recip_Vector(v,lam=1.):
d = sqrt(dot(v,v))**-1
theta = asin(lam/(2*d)) #Should always work
v1 = dot(v,e1func())
v2 = dot(v,e2func())
v3 = dot(v,e3func())
a_ = -v2
b_ = v1
c_ = (1./lam)*(cos(2*theta)-1)
c = 2*sin(theta)**2
a = v2
b = -v1
if a_<0:
phi = (math.pi - asin((b_)/sqrt(a_**2+b_**2)))
w = asin((c_)/sqrt(a_**2+b_**2)) - phi
else:
phi = asin((b_)/sqrt(a_**2+b_**2))
w = asin((c_)/sqrt(a_**2+b_**2)) - phi
w1 = w
wmax = math.pi/2. - phi
w2 = w1 + 2*abs(w1-wmax)
beta = asin(lam*v3) #should be ok with single value
alpha1 = acos((2*sin(theta)**2 - 1 )/-cos(beta))
alpha2 = -acos((2*sin(theta)**2 - 1 )/-cos(beta))
s_s0_1 = Construct_s_a_b(alpha1,beta) - e1func()
s_s0_2 = Construct_s_a_b(alpha2,beta) - e1func()
R1 = Rodrigues(w1)
R2 = Rodrigues(w2)
ws = [w1,w2]
alphas = [alpha1,alpha2]
betas = [beta]
sols = inv_dict()
tol = 1
ct = 0
for i in range(len(ws)):
for j in range(len(alphas)):
for k in range(len(betas)):
w,alpha,beta = ws[i],alphas[j],betas[k]
diff = Mag(Get_Recip_Vector(w,alpha,beta,lam)-v)
if diff < tol:
sols.Add(ct,(w,alpha,beta))
ct+=1
try:
if len(sols.keys())!=2:
raise Exception, "only one solution" +w1.__str__()+'_'+w2.__str__()
return sols
except Exception:
print "only 1 solution"
return sols
def Find_Friedel_Pairs(rIs,search_radius = 'default'):
friedel_pairs = inv_dict()
for rI_index in rIs.raw_data.keys():
rI = rIs.raw_data[rI_index]
friedel_pair = -rI
pairs_found = rIs.Query_Point(friedel_pair,search_radius)
for pair_found in pairs_found:
friedel_pairs.Add(rI_index,pair_found)
#friedel_pairs:{dataid1 : fridelpair_of_dataid1}
#friedel_pairs:{dataid2 : (fridelpair1_of_dataid2, friedelpair2_of_dataid2,...)
return friedel_pairs
def Get_Pixel_Polar_Coords(v,lam=1.,tol = 10**-3):
#print 'trying',v,lam,tol
sols = inv_dict()
g1,g2,g3 = v
d = Mag(v)**-1
try:
theta = asin(lam/(2*d))
beta = acos(lam*g3)
alpha1 = acos(cos(2*theta)/sin(beta))
except ValueError:
return sols
alpha2 = -alpha1
alphas = [alpha1,alpha2]
A = -g2
B = g1
if A>=0:
phi = asin(B/sqrt(A**2+B**2))
else:
phi = math.pi - asin(B/sqrt(A**2+B**2))
C = (cos(2*theta) - 1)/lam
w1 = asin(C/(sqrt(A**2+B**2)))-phi
#what quadrant is R.v
w_max = math.pi/2. - phi
w2 = w1 + 2*abs((w_max - w1))
Rv = dot(Rodrigues3(e3func(),w1),v)
quadrant = Quadrant2D(Rv,e1 = e1func(),e2 = e2func())
w1 = CCW(w1)
w2 = CCW(w2)
if quadrant == 2:
pair1 = [w1,alpha1,beta]
pair2 = [w2,alpha2,beta]
elif quadrant == 3:
#alpha should be negative here
pair1 = [w1,alpha2,beta]
pair2 = [w2,alpha1,beta]
tol = Mag(v*lam)*tol
ct = 0
for w,a,b in [pair1,pair2]:
g_c = From_Pixel_Polar_Coords(w,a,b,lam)
if Mag(g_c-v)<tol:
#raise Exception, "does not match"
sols.Add(ct,(w,a,b))
ct+=1
if len(sols.keys())==1:
print 'only one solution'
sols.Add(sols.keys()[0]+1,sols[sols.keys()[0]])
return sols #pair1,pair2
def Get_LLNL_Angles(v, lam = 1., tol = 1e-3):
my_e1 = -e3func()
my_e2 = -e1func()
my_e3 = e2func()
R__= Bond(my_e1,e1func())+Bond(my_e2,e2func())+Bond(my_e3,e3func())
my_v = dot(R__.T,v)
sols = Get_Pixel_Polar_Coords(my_v, lam, tol)
sol_eta_theta = inv_dict()
for sol_num in sols.keys():
w,a,b = sols[sol_num]
eta,theta = alphabeta_polar_to_etatheta(a,b)
sol_eta_theta[sol_num] = [2*theta,eta,w]
return sol_eta_theta
def Get_Pixel_Polar_Coords_2(v,lam=1.,tol = 10**-3):
g1,g2,g3 = v
d = Mag(v)**-1
theta = asin(lam/(2*d))
beta = acos(lam*g3)
eta1 = asin(cos(beta)/sin(2*theta))
difference = math.pi/2 - abs(eta1) #always positive
eta2 = eta1 + 2*difference*numpy.sign(eta1)
alpha1 = acos(cos(2*theta)/sin(beta))
alpha2 = -alpha1
alphas = [alpha1,alpha2]
etas = [eta1,eta2]
A = -g2
B = g1
if A>=0:
phi = asin(B/sqrt(A**2+B**2))
else:
phi = math.pi - asin(B/sqrt(A**2+B**2))
C = (cos(2*theta) - 1)/lam
w1 = asin(C/(sqrt(A**2+B**2)))-phi
#what quadrant is R.v
w_max = math.pi/2. - phi
w2 = w1 + 2*abs((w_max - w1))
Rv = dot(Rodrigues3(e3func(),w1),v)
quadrant = Quadrant2D(Rv,e1 = e1func(),e2 = e2func())
w1 = CCW(w1)
w2 = CCW(w2)
if quadrant == 2:
pair1 = [w1,eta2,theta]
pair2 = [w2,eta1,theta]
elif quadrant == 3:
#alpha should be negative here
pair1 = [w1,eta1,theta]
pair2 = [w2,eta2,theta]
tol = Mag(v*lam)*tol
sols = inv_dict()
ct = 0
for w,e,t in [pair1,pair2]:
g_c = From_Pixel_Polar_Coords_2(w,e,t,lam)
if Mag(g_c-v)<tol:
#raise Exception, "does not match"
sols.Add(ct,(w,e,t))
ct+=1
if len(sols.keys())==1:
print 'only one solution'
sols.Add(ct+1,sols[sols.keys()[0]])
return sols#pair1,pair2
def Query_Point(self,input_vector,search_radius = 'default'):
if search_radius == 'default':
search_radius = self.dx
x_seed,y_seed,z_seed = self.base_map(input_vector,**self.core_kwargs)
dx,dy,dz = self.dx,self.dy,self.dz
#ix = Int_Map(float(x)/dx)
#iy = Int_Map(float(y)/dy)
#iz = Int_Map(float(z)/dz)
#x_seed, y_seed, z_seed = seed_pt
x_ = Int_Map(search_radius/self.dx)
y_ = Int_Map(search_radius/self.dy)
z_ = Int_Map(search_radius/self.dz)
x_array = numpy.arange(2*x_+1)-x_
y_array = numpy.arange(2*y_+1)-y_
z_array = numpy.arange(2*z_+1)-z_
keys = []
keys2 = inv_dict()
for i in range(len(x_array)):
for j in range(len(y_array)):
for k in range(len(z_array)):
x = x_seed + x_array[i]*self.dx
ix = Int_Map(x/self.dx)
y = y_seed+y_array[j]*self.dy
iy = Int_Map(y/self.dy)
z = z_seed + z_array[k]*self.dz
iz = Int_Map(z/self.dz)
key = (ix,iy,iz)
if self.xyzdict.has_key(key):
if self.xyzdict.triggerdict[key]==1:
#multiple data_ids at this query point, use extend
list_keys = list(self.xyzdict[key])
keys.extend(list_keys)
#for data_id in self.xyzdict[key]:
# keys2.Add(data_id,key) #should only have one key per data_id
else:
#single value, use append
keys.append(self.xyzdict[key])
#data_id = self.xyzdict[key]
#keys2.Add(data_id,key)
else:
pass
return keys
def __init__(self,dx,dy,dz,da1,da2,da3,fmap,inv_fmap,b1 = e1func(),b2 = e2func(), b3 = e3func(), base_map = Get_Cartesian, inv_base_map = From_Cartesian):
Vector_Data.__init__(self,dx,dy,dz,b1 = b1, b2 = b2, b3 = b3, base_map = base_map, inv_base_map = inv_base_map)
self.da1 = da1
self.da2 = da2
self.da3 = da3
self.a1_dict = inv_dict()
self.a2_dict = inv_dict()
self.a3_dict = inv_dict()
self.a1_a2_dict = inv_dict()
self.a2_a3_dict = inv_dict()
self.a3_a1_dict = inv_dict()
self.a1_a2_a3_dict = inv_dict()
self.fmap = fmap
self.inv_fmap = inv_fmap
self.kwargs = {}
self.allow_unique = True
def map_to_fundamental(sym_rots,R):
tmp = inv_dict()
for i in range(len(sym_rots)):
rot = sym_rots[i]
Rmap = dot(R,rot.T)
w,(r,theta,phi) = Find_Rotation_Comps(Rmap)
tmp.Add(abs(w),(theta,phi,numpy.sign(w)))
keys = tmp.keys()
min_w = min(keys)
if tmp.triggerdict[min_w]==0:
theta,phi,sgn = tmp[min_w]
else:
theta,phi,sgn = tmp[min_w][0]
axis = erhofunc(theta,phi)
mag = tan(min_w*sgn/2.)
r_pos = mag*axis
x,y,z = r_pos
return r_pos
def EigenDict(C):
eval,evec = eig(C)
b = inv_dict()
c = {}
#convert to real, allocate eigenvectors
for i in range(len(eval)):
b[i] = float(eval[i])
c[i] = evec[:,i]
b.Flip()
keys = b.keys()[:]
keys.sort()
order = []
if b.Contains_Extended() == False:
for j in range(len(eval)):
order.append(b[keys[j]])
else:
raise AttributeError,"multiples"
for j in range(len(b.keys())):
order.append(b[keys[j]])
final_lambda_dict = {}
final_evec_dict = {}
b.Flip()
for k in range(len(order)):
elem = order[k]
final_lambda_dict[k] = b[elem]
final_evec_dict[k] = c[elem]
ret = {}
ret['eval']=final_lambda_dict
ret['evec']=final_evec_dict
tol = 10**-8
for i in range(len(ret['evec'].keys())):
key = ret['evec'].keys()[i]
for j in range(len(ret['evec'].keys())):
key2 = ret['evec'].keys()[j]
if i!=j:
if dot(ret['evec'][key],ret['evec'][key2]) > tol:
warnings.warn('not orthogonal')
return ret
def Query_Orientation(gIs, rIs, Rtrial,search_radius = 'default'):
"""gIs: inv_dict
rIs: Vector_Data_Structure
"""
num_hkls = len(gIs.keys())
slots = inv_dict()
for key in gIs.keys():
gI_vals = gIs[key]
if gIs.triggerdict[key]==1:
for gI in gI_vals:
r_test = dot(Rtrial,gI)
hits = rIs.Query_Point(r_test,search_radius)
for hit in hits:
slots.Add(key,hit)
else:
r_test = dot(Rtrial,gI_vals)
hits = rIs.Query_Point(r_test,search_radius)
for hit in hits:
slots.Add(key,hit)
return slots
def Query_Orientation_Unique(gIs,rIs,Rtrial,search_radius = 'default'):
"""gIs: indexing_hkls_struct
rIs: Vector_Data_Structure
"""
num_hkls = len(gIs.keys())
slots = inv_dict()
allids = {}
ct = 0
crystal_struct = layered_data({})
for key in gIs.keys():
gI = gIs[key]
r_test = dot(Rtrial,gI)
hits = rIs.Query_Point(r_test,search_radius)
if len(hits)>1:
print "grain splitting"
for hit in hits:
crystal_struct.SplitLayer
else:
assoc = tuple(key,hits[0])
crystal_struct.AddItemToAll((key,hits[0]))
return ct
def Get_Pixel_Coords_From_Recip_Vector(v,center_px,procession,L0,lam=1.,tol = 10**-3,mm_per_px = .2):
"""must be given center_px in row,col array (0,0) in upper left facing the detector
returns w,row,col"""
sols = Get_Pixel_Polar_Coords(v,lam,tol)
#pixel bases
p1 = -e3func()
p2 = -e2func()
#detector_basis
d1 = -e2func()
d2 = e3func()
#detector origin
#center_px
tmp_center = Pixel(center_px)
tmp = Pixel((0,0))#just for function access later
final_pxs = inv_dict()
for key in sols.keys():
w,a,b = sols[key]
#eta,theta = alphabeta_polar_to_etatheta(a,b)
R = Rodrigues3(e3func(),w)
G_pos = dot(R,procession)
proc_x = dot(G_pos,e1func())
L_act = L0 - proc_x
s = Construct_s_s0_Polar_Coords(a,b)+e1func()
#or, s = erhofunc(b,a,p=e3func(),q=e1func(),r=e2func()) = erhofunc(b,a)
Hyp = L_act/dot(s,e1func())
r_act = G_pos + Hyp*s
Proj = Proj_func(e1func())
rel_pixel_pos = r_act/mm_per_px
Pr = dot(Proj,rel_pixel_pos)
x_rel_pos = dot(Pr,-e2func())
y_rel_pos = dot(Pr,e3func())
loc = tmp.from_x_y((x_rel_pos,y_rel_pos),origin = tmp_center.pos)
prow,pcol = tmp.to_row_col(loc)
final_pxs.Add(key,(w,prow,pcol))
return final_pxs
a1a2a3keys = numpy.array(self.a1_a2_a3_dict.keys()) #so slicing works
a1slice = a1a2a3keys[:,0] #column 1 key = (a1,a2,a3)
a2slice = a1a2a3keys[:,1] #column 2 key = (a1,a2,a3)
a3slice = a1a2a3keys[:,2] #column 3 key = (a1,a2,a3)
#now find the values within the sliced range
a1s = self.GetArray(a1slice,a1_min,a1_max);a1s = numpy.unique(a1s)
a2s = self.GetArray(a2slice,a2_min,a2_max);a2s = numpy.unique(a2s)
a3s = self.GetArray(a3slice,a3_min,a3_max);a3s = numpy.unique(a3s)
tmp = self.a1_a2_a3_dict
#tmp : {fmap(data_id) : data_id}
tmp2 = tmp.Get_Flipped_Copy()
#tmp2 : {data_id : fmap(data_id)}
out = inv_dict()
ct=0
for a1key in a1s:
for a2key in a2s:
for a3key in a3s:
key = (a1key,a2key,a3key) #form all possible a1,a2,a3 in the valid range
if tmp.has_key(key):
data_ids = tmp[key] #tmp_out is the unique identifier(s) (if trigger = 1, multiples)
if tmp.triggerdict[key]==1:
for data_id in data_ids:
#the following snip is the same for if triggerdict = 0
stor = []
if tmp2.triggerdict[data_id]==1: #if there are multiple associations to this vector (true for most) e.g. if a vector input has more than one fmap result
for m in range(len(tmp2[data_id])): #usually range(2)
a1,a2,a3 = tmp2[data_id][m]
if (a1_min<=a1<=a1_max) and (a2_min<=a2<=a2_max) and (a3_min<=a3<=a3_max):
def Reset(self):
kwargs = self.kwargs
raw_data = self.raw_data
self.a1_dict = inv_dict();self.a2_dict = inv_dict();self.a3_dict = inv_dict(); self.a1_a2_dict = inv_dict();self.a2_a3_dict = inv_dict(); self.a3_a1_dict = inv_dict(); self.a1_a2_a3_dict = inv_dict()
for key in raw_data.keys():
self.Add(raw_data[key],key,**kwargs)
def Base_Reset(self):
raw_data = self.raw_data.Copy()
self.raw_data = inv_dict()
self.xyzdict = inv_dict()
for key in raw_data.keys():
self.Add(key,raw_data[key])
