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])