Example #1
0
def rotation_angle(M,Z,L,index=0):
    theta = []
    v1 = []
    sides = Z.shape[1]/M.shape[1]
    for i in range(M.shape[0]):
        v1.append(points.vector1d(M[i][index],Z[i][index*sides],L[i]))
    for i in range(M.shape[0]-1):
        theta.append(points.angle_between(v1[i],v1[i+1]))
    return theta
Example #2
0
def old_cubatic_order(M,Z,L,select=0):
    #Choose references cube 
    ref = M[0][select]
    us  = points.unit(points.vector1d(ref,Z[0][select*6],L))
    ws  = points.unit(points.vector1d(ref,Z[0][select*6+1],L))
    vs  = points.unit(points.vector1d(ref,Z[0][select*6+4],L))
    ####################################################
    #Create u,w,v based on best alignment with reference cube
    u = []
    v = []
    w = []
    for k in range(M.shape[0]):
        for i in range(M.shape[1]):
            if i != select:
                vc = cube_vectors(M[k][i],Z[k][i*6:i*6+6],L)
                usmall = 0
                vsmall = 0
                wsmall = 0
                for j in range(1,len(vc)):
                    if points.angle_between(us,vc[j])<=points.angle_between(us,vc[usmall]):
                        usmall = j
                    if points.angle_between(ws,vc[j])<=points.angle_between(ws,vc[wsmall]):
                        wsmall = j
                    if points.angle_between(vs,vc[j])<=points.angle_between(vs,vc[vsmall]):
                        vsmall = j
                u.append(vc[usmall])
                v.append(vc[vsmall])
                w.append(vc[wsmall])
            else:
                u.append(ws)
                v.append(us)
                w.append(vs)
    #Find Ordering Tesnors
    Quu = np.zeros((3,3))
    Qww = np.zeros((3,3))
    Qvv = np.zeros((3,3))
    for N in range(len(u)):
        for i in range(3):
            for j in range(3):
                Quu[i,j] += 3. * u[N][i]*u[N][j] - delta(i,j)
                Qvv[i,j] += 3. * v[N][i]*v[N][j] - delta(i,j)
                Qww[i,j] += 3. * w[N][i]*w[N][j] - delta(i,j)
    Quu = Quu / (2.*len(u))
    Qvv = Qvv / (2.*len(v))
    Qww = Qww / (2.*len(w))
    #Find eigenvalues
    e_w = np.linalg.eig(Qww)
    e_u = np.linalg.eig(Quu)
    e_v = np.linalg.eig(Qvv)
    #Identify Laboratory Z,Y and X axis
    #print e_w,'\n',e_u,'\n',e_v
    def find_max(e):
        evalue = e[0][0]
        index = 0
        if e[0][1] > evalue:
            evalue = e[0][1]
            index = 1
        if e[0][2] > evalue:
            evalue = e[0][2]
            index = 2
        return evalue, index
    #get index of eigenvector and evalue
    e_plus_v = find_max(e_v)
    e_plus_u = find_max(e_u)
    e_plus_w = find_max(e_w)
    #find Z
    s = []
    if e_plus_v[0] == max(e_plus_v[0],e_plus_u[0],e_plus_w[0]):
        z = e_v[1][e_plus_v[1]]
        Qz = Qvv
        s.append(0)
    if e_plus_v[0] == min(e_plus_v[0],e_plus_u[0],e_plus_w[0]):
        x = e_v[1][e_plus_v[1]]
        Qx = Qvv
        s.append(0)
    if e_plus_u[0] == max(e_plus_v[0],e_plus_u[0],e_plus_w[0]):
        z = e_u[1][e_plus_u[1]]
        Qz = Quu
        s.append(1)
    if e_plus_u[0] == min(e_plus_v[0],e_plus_u[0],e_plus_w[0]):
        x = e_u[1][e_plus_u[1]]
        Qx = Quu
        s.append(1)
    if e_plus_w[0] == max(e_plus_v[0],e_plus_u[0],e_plus_w[0]):
        z = e_w[1][e_plus_w[1]]
        Qz = Qww
        s.append(2)
    if e_plus_w[0] == min(e_plus_v[0],e_plus_u[0],e_plus_w[0]):
        x = e_w[1][e_plus_w[1]]
        Qx = Qww
        s.append(2)
    if len(s) != 2:
        print 'error too Qx and Qz were not selected properly'
        asdfasdf

    if 0 not in s:
        y = e_v[1][e_plus_v[1]]
        Qy = Qvv
        s.append(0)
    if 1 not in s:
        y = e_u[1][e_plus_u[1]]
        Qy = Quu
        s.append(1)
    if 2 not in s:
        y = e_w[1][e_plus_w[1]]
        Qy = Qww
        s.append(2)

    x = np.cross(z,y)
    #print 'angles between Laboratory'
    print points.angle_between(z,y)

    #Find Q22 and Q00
    Q00 = np.dot(np.dot(z,Qz),z)

    #Q00 = (np.dot(np.dot(z,Qz),z)+np.dot(np.dot(y,Qy),y)+np.dot(np.dot(x,Qx),x))/3.
    Q22 = (np.dot(np.dot(x,Qx),x) + np.dot(np.dot(y,Qy),y) -
            np.dot(np.dot(x,Qy),x) - np.dot(np.dot(y,Qx),y))/3.

    return Q00, Q22
Example #3
0
def cube_allign(M,Z,L):
    u_vectors = []
    #sp6 last-10
    #u_vectors.append(np.array(([-1/3**0.5, 1/3.**0.5, 1/3.**0.5])))
    #u_vectors.append(np.array(([0, 1/2**0.5, 1/2.**0.5])))
    #u_vectors.append(np.array(([-1/2**0.5, 1/2.**0.5, 0])))
    #u_vectors.append(np.array(([-1/2**0.5, 0, 1/2.**0.5])))
    #sp12 last-10
    u_vectors.append(np.array(([1/3**0.5, 1/3.**0.5, 1/3.**0.5])))
    u_vectors.append(np.array(([0, 1/2**0.5, 1/2.**0.5])))
    u_vectors.append(np.array(([1/2**0.5, 1/2.**0.5, 0])))
    u_vectors.append(np.array(([1/2**0.5, 0, 1/2.**0.5])))

    U = []
    for i in range(M.shape[0]):
        vc = cube_vectors(M[i],Z[i*6:i*6+6],L)
        u_small = 0
        for k in range(len(vc)):
            theta = points.angle_between(u_vectors[0],vc[u_small])
            theta_new = points.angle_between(u_vectors[0],vc[k])
            if theta_new<=theta:
                u_small = k
                t = points.angle_between(u_vectors[0],vc[u_small])
        U.append(vc[u_small])
    ###############################################################
    assign_vectors = []
    for i in range(len(U)):
        u_small = 0
        theta = points.angle_between(u_vectors[u_small],U[i])
        for k in range(len(u_vectors)):
            theta_new = points.angle_between(u_vectors[k],U[i])
            if theta_new<=theta:
                u_small = k
                theta = theta_new
        assign_vectors.append(u_small)
    #write to vmd an arrow to draw
    fid2 = open('color_index.txt','w')
    fid = open('arrows.tcl','w')
    fid.write('proc vmd_draw_arrow {mol start end} { \n '+
              'set middle [vecadd $start [vecscale 0.9 [vecsub $end $start]]] \n' +
               'graphics $mol cylinder $start $middle radius 0.5\n' + 
               'graphics $mol cone $middle $end radius 0.75\n}\n\n')

    def draw_arrow(fid, VW, u_vectors, index):
            x = 5 * u_vectors[0] + VW[i][0]
            y = 5 * u_vectors[1] + VW[i][1]
            z = 5 *  u_vectors[2] + VW[i][2]
            fid.write(('draw arrow {%.2f %.2f %.2f} {%.2f %.2f %.2f}\n'
                                   %(VW[i][0], VW[i][1], VW[i][2], x, y, z)))
    for i in range(len(assign_vectors)):
            if assign_vectors[i] == 0:
                fid.write('draw color blue\n')
                fid2.write('0\n')
                draw_arrow(fid, M,u_vectors[0],i)
            if assign_vectors[i] == 1:
                fid.write('draw color red\n')
                fid2.write('1\n')
                draw_arrow(fid, M,u_vectors[1],i)
            if assign_vectors[i] == 2:
                fid.write('draw color green\n')
                fid2.write('2\n')
                draw_arrow(fid, M,u_vectors[2],i)
            if assign_vectors[i] == 3:
                fid.write('draw color orange\n')
                fid2.write('3\n')
                draw_arrow(fid, M,u_vectors[3],i)

    fid.close()
Example #4
0
def cubatic_order_eigenvalues(M,Z,L,frame=1,delta=5):
    #us = np.array(([1/3.**0.5,1/3.**0.5,1/3.**0.5]))
    #ws = np.array(([1/2.**0.5,0,-1/2.**0.5]))
    #vs = np.array(([1/6.**0.5,-2/6.**0.5,1/6.**0.5]))
    #us = np.array(([1,0,0]))
    #ws = np.array(([0,1,0]))
    #vs = np.array(([0,0,1]))
    u_vectors = []
    import math
    #north south and east poles
    #for i in range(5):
    #    u_vectors.append(np.array(([0, math.sin(i*math.pi/(6*4)),
    #        math.cos(i*math.pi/(6.*4))])))
    #u_vectors.append(np.array(([0.72, .37, .59])))
    #v = np.array([-6.86,-6.46,7.43])
    #v = np.array([44.7-56.0,2.76,25.469])
    #u_vectors.append(v/np.dot(v,v)**0.5)
    #v = np.array(([-4.59, -0.01, 11.09]))
    #u_vectors.append(v/np.dot(v,v)**0.5)
    #v = np.array(([-2.98, -2.25, 11.41]))
    #u_vectors.append(v/np.dot(v,v)**0.5)
    v = np.array(([-9.38, 7.28, -1.78]))
    u_vectors.append(v/np.dot(v,v)**0.5)
    #u_vectors.append(np.array(([1, 0, 0])))
    #u_vectors.append(np.array(([0, 1, 0])))
    #u_vectors.append(np.array(([0, 0, 1])))
    #u_vectors.append(np.array(([1/3.**0.5, 1/3.**0.5, 1/3.**0.5])))
    ##u_vectors.append(np.array(([-1/3.**0.5, 1/3.**0.5, 1/3.**0.5])))
    ###u_vectors.append(np.array(([0, 1/2.**0.5, 1/2.**0.5])))
    #u_vectors.append(np.array(([1/2.**0.5, 0, 1/2.**0.5])))
    #u_vectors.append(np.array(([1/2.**0.5, 1/2.**0.5, 0])))
    #u_vectors.append(np.array(([-1/2.**0.5, 1/2.**0.5, 0])))
    #u_vectors.append(np.array(([-1/2.**0.5, 0, 1/2.**0.5])))


    #fid = open('gaussmap%.2f.xyz'%L[0],'w')
    fid = open('gaussmap%.2f.xyz'%frame,'w')
    fid.write('%i\n\n'%(M.shape[1]*6*M.shape[0]))
    ####################################################
    #Create Master Vector
    #U = [[] for i in range(len(u_vectors))]
    #count = [[0,i] for i in range(len(u_vectors))]
    #theta = 1.4
    #for index in range(delta):
    #    for i in range(M[index].shape[0]):
    #        vc = cube_vectors(M[index][i],Z[index][i*6:i*6+6],L)
    #        for j in range(len(vc)):
    #            fid.write(('N %.2f %.2f %.2f\n')%(vc[j][0],vc[j][1],vc[j][2]))
    #            for k in range(len(u_vectors)):
    #                if points.angle_between(u_vectors[k],vc[j]) < theta:
    #                    U[k].append(vc[j])
    U = [[] for i in range(len(u_vectors))]
    count = [[0,i] for i in range(len(u_vectors))]
    for index in range(delta):
        for i in range(M[index].shape[0]):
            vc = cube_vectors(M[index][i],Z[index][i*6:i*6+6],L)
            for r in range(len(vc)):
                fid.write(('N %.2f %.2f %.2f\n')%(vc[r][0],vc[r][1],vc[r][2]))
            u_small = [0 for j in range(len(u_vectors))]
            for j in range(len(u_small)):
                for k in range(len(vc)):
                    theta = points.angle_between(u_vectors[j],vc[u_small[j]])
                    theta_new = points.angle_between(u_vectors[j],vc[k])
                    if theta_new<=theta:
                        u_small[j] = k 
                        t = points.angle_between(u_vectors[j],vc[u_small[j]])
                U[j].append(vc[u_small[j]])
    fid.close()
    def order_parameter(e):
        #bakos 
        b_lamda1 = (13+3*17**0.5)/36.
        b_lamda2 = 5/18.
        b_lamda3 = (13-3*17**0.5)/36.
        #isotropic
        i_lamda1 = 0.701
        i_lamda2 = 0.15
        i_lamda3 = 0.15
        e.sort()
        e = e[::-1]
        print e
        i_order = ((abs(e[0] - i_lamda1) +
                 abs(e[1] - i_lamda2) +
                 abs(e[2] - i_lamda3)) )
                 #(abs(1-i_lamda1)+i_lamda2 + i_lamda3))
        b_order = ((abs(e[0] - b_lamda1) +
                 abs(e[1] - b_lamda2) +
                 abs(e[2] - b_lamda3)) )
                #(abs(1-b_lamda1)+b_lamda2 + b_lamda3))
        #o = (abs(e[1]-i_lamda2)/(b_lamda2-i_lamda2)  +
        #    abs(e[2]-i_lamda3)/(i_lamda3-b_lamda3)  )
        return i_order/0.6

    def Nab(u):
        Quu = np.zeros((3,3))
        for N in range(len(u)):
            for i in range(3):
                for j in range(3):
                    Quu[i,j] +=  u[N][i]*u[N][j]
        Quu = Quu / (len(u))
        e_u = np.linalg.eig(Quu)
        return Quu,e_u
    order = []
    for vv,u in enumerate(U):
        Nuu, e_u = Nab(u)
        print 'vectors'
        print u_vectors[vv]
        print 'Nab'
        print Nuu
        Mab(Nuu)
        #print '----------------------'
        #print 'allign vector'
        #print u_vectors[vv]
        #print 'Quu_ab'
        #print Nuu
        #print 'eigan values of <n_a,n_b>'
        #print e_u[0]
        #print '----------------------'
        order.append(order_parameter(e_u[0]))

    #gauss map
    fid = open('vectors%i.xyz'%frame,'w')
    m = 0
    fid.write(('%i\n\n')%(len(U[0])))
    fid.write('Z 0 0 0\n')
    fid.write(('Z %.4f %.4f %.4f\n')%(u_vectors[m][0],u_vectors[m][1],u_vectors[m][2]))
    for v in U[m]:
        fid.write(('N %.4f %.4f %.4f\n')%(v[0],v[1],v[2]))
    fid.close()
    return sum(order)/len(order)
Example #5
0
def cubatic_order(M,Z,L,frame=1):
    #us = np.array(([1/3.**0.5,1/3.**0.5,1/3.**0.5]))
    #ws = np.array(([1/2.**0.5,0,-1/2.**0.5]))
    #vs = np.array(([1/6.**0.5,-2/6.**0.5,1/6.**0.5]))
    #us = np.array(([1,0,0]))
    #ws = np.array(([0,1,0]))
    #vs = np.array(([0,0,1]))
    u_vectors = []
    u_vectors.append(np.array(([1/3.**0.5, 1/3.**0.5, 1/3.**0.5])))
    u_vectors.append(np.array(([-1/3.**0.5, 1/3.**0.5, 1/3.**0.5])))
    u_vectors.append(np.array(([0, 1/2.**0.5, 1/2.**0.5])))
    u_vectors.append(np.array(([1/2.**0.5, 0, 1/2.**0.5])))
    u_vectors.append(np.array(([1/2.**0.5, 1/2.**0.5, 0])))
    u_vectors.append(np.array(([-1/2.**0.5, 1/2.**0.5, 0])))
    u_vectors.append(np.array(([-1/2.**0.5, 0, 1/2.**0.5])))
    u_vectors.append(np.array(([1, 0, 0])))
    u_vectors.append(np.array(([0, 1, 0])))
    u_vectors.append(np.array(([0, 0, 1])))


    for again in range(2):
        if again == 0:
            fid = open('gaussmap.xyz','w')
            fid.write('%i\n\n'%(M.shape[0]*6))
        ####################################################
        #Create Master Vector
        U = [[] for i in range(len(u_vectors))]
        count = [[0,i] for i in range(len(u_vectors))]
        for i in range(M.shape[0]):
            vc = cube_vectors(M[i],Z[i*6:i*6+6],L)
            if again == 0:
                for i in range(len(vc)):
                    fid.write(('N %.2f %.2f %.2f\n')%(vc[i][0],vc[i][1],vc[i][2]))
            u_small = [0 for j in range(len(u_vectors))]
            for j in range(len(u_small)):
                for k in range(len(vc)):
                    theta = points.angle_between(u_vectors[j],vc[u_small[j]])
                    theta_new = points.angle_between(u_vectors[j],vc[k])
                    if theta_new<=theta:
                        u_small[j] = k 
                        t = points.angle_between(u_vectors[j],vc[u_small[j]])
                if t < 1.5:
                    U[j].append(vc[u_small[j]])
                else:
                    count[j][0]+=1
        fid.close()


        def Qab(u):
            Quu = np.zeros((3,3))
            for N in range(len(u)):
                for i in range(3):
                    for j in range(3):
                        Quu[i,j] +=  u[N][i]*u[N][j]
            Quu = Quu / (len(u))
            e_u = np.linalg.eig(Quu)
            return Quu,e_u
        eigen_values = []
        for vv,u in enumerate(U):
            Quu, e_u = Qab(u)
            Mab(Quu)
            print '----------------------'
            print 'allign vector'
            print u_vectors[vv]
            print 'Quu_ab'
            print Quu
            print 'eigan values of <n_a,n_b>'
            print e_u[0]
            #print 'eigan values of <n_a,n_b>'
            #print e_u[1]
            #print '----------------------'
            eigen_values.append(max(e_u[0]))
        #count.sort()
        #print count
        ### TO DO
        if again <1:
            m = eigen_values.index(max(eigen_values))
            new_vector = points.line_3D_fit(np.array(U[m]))
            u_vectors.append(new_vector)
    fid = open('vectors%i.xyz'%frame,'w')
    m = eigen_values.index(max(eigen_values))
    fid.write('130\n\n')
    fid.write('Z 0 0 0\n')
    fid.write(('Z %.4f %.4f %.4f\n')%(u_vectors[m][0],u_vectors[m][1],u_vectors[m][2]))
    for v in U[m]:
        fid.write(('N %.4f %.4f %.4f\n')%(v[0],v[1],v[2]))
    fid.close()
    print max(eigen_values)
    print '--'
    if max(eigen_values) == eigen_values[-1]:
        print 'new is better!'
    return (max(eigen_values)-0.7)/.3
Example #6
0
def allign(v1,v2,v3):
    vc = [v1,v2,v3]
    us = np.array([1,1,1])
    vs = np.array([1,1,-1])
    ws = np.array([1,-1,1])
    usmall = 0
    vsmall = 0
    wsmall = 0
    angle = []
    for j in range(3):
        angle.append([points.angle_between(us,vc[j]),j])
    angle.sort()
    if angle[0][0] <1.0:
        print 'swapping'
        if points.angle_between(us,-vc[angle[-1][1]])<1.0:
            vc[angle[-1][1]] = -vc[angle[-1][1]]
            print points.angle_between(us,vc[angle[-1][1]])
        if points.angle_between(us,-vc[angle[-2][1]])<1.0:
            vc[angle[-2][1]] = -vc[angle[-2][1]]
            print points.angle_between(us,vc[angle[-2][1]])
    x = [0,1,2]
    for j in x:
        if points.angle_between(us,vc[j])<=points.angle_between(us,vc[usmall]):
            usmall = j
    del x[usmall]
    wsmall = x[0]
    print x
    for j in x:
        if points.angle_between(ws,vc[j])<=points.angle_between(ws,vc[wsmall]):
            wsmall = j
    del x[x.index(wsmall)]
    vsmall = x[0]
    print usmall,wsmall,vsmall
    return vc[usmall], vc[wsmall], vc[vsmall]