def run_cross_section(interactionfile, spinfile): start = clock() # Generate Inputs atom_list, jnums, jmats,N_atoms_uc=readFiles(interactionfile,spinfile) atom_list=atom_list[:N_atoms_uc] N_atoms = len(atom_list) kx = sp.Symbol('kx', real = True) ky = sp.Symbol('ky', real = True) kz = sp.Symbol('kz', real = True) k = spm.Matrix([kx,ky,kz]) (b,bd) = generate_b_bd_operators(atom_list) (a,ad) = generate_a_ad_operators(atom_list, k, b, bd) (Sp,Sm) = generate_Sp_Sm_operators(atom_list, a, ad) (Sa,Sb,Sn) = generate_Sa_Sb_Sn_operators(atom_list, Sp, Sm) (Sx,Sy,Sz) = generate_Sx_Sy_Sz_operators(atom_list, Sa, Sb, Sn) print '' #Ham = generate_Hamiltonian(N_atoms, atom_list, b, bd) ops = generate_possible_combinations(atom_list, [Sx,Sy,Sz]) ops = holstein(atom_list, ops) ops = apply_commutation(atom_list, ops) ops = replace_bdb(atom_list, ops) ops = reduce_options(atom_list, ops) list_print(ops) print "prelims complete. generating cross-section","\n" aa = bb = cc = np.array([2.0*np.pi], 'Float64') alpha = beta = gamma = np.array([np.pi/2.0], 'Float64') vect1 = np.array([[1,0,0]]) vect2 = np.array([[0,0,1]]) lattice = Lattice(aa, bb, cc, alpha, beta, gamma, Orientation(vect1, vect2)) tau_list = [] for i in range(1): tau_list.append(np.array([0,0,0], 'Float64')) h_list = np.linspace(0.1,6.3,50) k_list = np.zeros(h_list.shape) l_list = np.zeros(h_list.shape) w_list = np.linspace(-10,10,50) (N_atoms_uc,csection,kaprange, tau_list,eig_list,kapvect,wtlist,fflist) = generate_cross_section(interactionfile, spinfile, lattice, ops, tau_list, h_list, k_list, l_list, w_list) print csection return N_atoms_uc,csection,kaprange,tau_list,eig_list,kapvect,wtlist,fflist end = clock() print "\nFinished %i atoms in %.2f seconds" %(N_atoms,end-start)
def optimization_driver(interfile, spinfile): """ runs the local optimization routine given just an interactionfile and spinfile. this should be called by the GUI """ atom_list, jnums, jmats, N_atoms_uc = rf.readFiles(interfile,spinfile,allAtoms=True) N_atoms = len(atom_list) jij = gen_Jij(atom_list,jmats) anis = gen_anisotropy(atom_list) sij = gen_spinVector(atom_list) Ham = calculate_Ham(sij, anis, jij) return local_optimizer(interfile, spinfile)
def run_dispersion_from_file(interactionfile,spinfile, eigs=False, eigsP = (False,None)): atom_list, jnums, jmats,N_atoms_uc=rf.readFiles(interactionfile,spinfile) N_atoms=len(atom_list) Hsave = calculate_dispersion(atom_list,N_atoms_uc,N_atoms,jmats,showEigs=eigs) if eigs == True: temp = 1 x = sp.Symbol('x') for i in range(Hsave.cols): temp *= x-Hsave[i,i] poly = sp.simplify(temp.expand()) print poly return sp.simplify(Hsave[0])
def optimization_driver(interfile, spinfile): """ runs the local optimization routine given just an interactionfile and spinfile. this should be called by the GUI """ atom_list, jnums, jmats, N_atoms_uc = rf.readFiles(interfile, spinfile, allAtoms=True) N_atoms = len(atom_list) jij = gen_Jij(atom_list, jmats) anis = gen_anisotropy(atom_list) sij = gen_spinVector(atom_list) Ham = calculate_Ham(sij, anis, jij) return local_optimizer(interfile, spinfile)
def local_optimizer(interfile, spinfile): """ Given an interaction file and a spin file, this optimizer will uses readfiles.readfiles to populate an atom list as well as return the interaction matrices. Given that information, it will recalculate the hamiltonian and attempt to minimize it as a function of theta and phi. The annealing will get the spins close to the global minimum and this method makes sure the spins are aligned. This routine uses only python instead of C. """ # Get atoms list, jmats from the interaction and spin files atom_list, jnums, jmats, N_atoms_uc = rf.readFiles(interfile, spinfile, allAtoms=True) return opt_aux(atom_list, jmats)
def cs_driver(): file_pathname = os.path.abspath('') interfile = os.path.join(file_pathname,r'montecarlo.txt') spinfile = os.path.join(file_pathname,r'spins.txt') h_list = np.linspace(0.001,3.14,15) k_list = np.zeros(h_list.shape) l_list = np.zeros(h_list.shape) w_list = np.linspace(0,5,15) tau = np.array([0,0,0]) wt = np.array(1.0) rad = 1.0 atom_list, jnums, jmats,N_atoms_uc=readFiles(interfile,spinfile) N_atoms_uc,csection,kaprange,tau_list,eig_list,kapvect,wt_list,fflist = run_cross_section(interfile,spinfile) x,y,z=run_spherical_averaging(N_atoms_uc,atom_list,rad,csection,kapvect,tau_list,eig_list,wt_list,temperature) np.save(os.path.join(file_pathname,r'myfilex.txt'),x) np.save(os.path.join(file_pathname,r'myfiley.txt'),y) np.save(os.path.join(file_pathname,r'myfilez.txt'),z)
def run_dispersion_from_file(interactionfile, spinfile, eigs=False, eigsP=(False, None)): atom_list, jnums, jmats, N_atoms_uc = rf.readFiles(interactionfile, spinfile) N_atoms = len(atom_list) Hsave = calculate_dispersion(atom_list, N_atoms_uc, N_atoms, jmats, showEigs=eigs) if eigs == True: temp = 1 x = sp.Symbol('x') for i in range(Hsave.cols): temp *= x - Hsave[i, i] poly = sp.simplify(temp.expand()) print poly return sp.simplify(Hsave[0])
def local_optimizer(interfile, spinfile): """ Given an interaction file and a spin file, this optimizer will uses readfiles.readfiles to populate an atom list as well as return the interaction matrices. Given that information, it will recalculate the hamiltonian and attempt to minimize it as a function of theta and phi. The annealing will get the spins close to the global minimum and this method makes sure the spins are aligned. This routine uses only python instead of C. """ # Get atoms list, jmats from the interaction and spin files atom_list, jnums, jmats,N_atoms_uc=rf.readFiles(interfile,spinfile,allAtoms=True) N_atoms = len(atom_list) # Generate the Jij and anisotropy arrays Jij = gen_Jij(atom_list,jmats) anis = gen_anisotropy(atom_list) # Get the spin magnitudes from the atoms in atom list spin_mags = [] for i in range(len(atom_list)): spin_mags.append(atom_list[i].spinMagnitude) spin_mags = np.array(spin_mags) # hamiltonian method def hamiltonian(p, Jij = None, spins = None, anis = None): """ Computes the hamiltonian given a list a thetas and phis""" # Thetas are the first half, phis the second half theta = p[:len(p)//2] phi = p[len(p)//2:] # Sx,Sy,Sz Sx = spins*cos(theta)*cos(phi) Sy = spins*cos(theta)*sin(phi) Sz = spins*sin(theta) # Array of spin vectors for each atom. Reshape it. Calculate hamiltonian with it and return the hamiltonian. Sij = np.array([Sx,Sy,Sz]) Sij = Sij.T.reshape(1,3*len(p)//2).T SijT =Sij.T # Normal mode # sij.T * jij * sij res1 = SijT * Jij Hij = np.dot(res1,Sij).flat[0] Ham = - Hij - np.dot(anis, Sij**2) return Ham # derivative of the hamiltonian def deriv(p, Jij = None, spins = None, anis = None): """ Computes the derivative of the hamiltonian with respect to each theta and then each phi""" # Thetas are the first half, phis the second half half = len(p)/2 theta = p[:half] phi = p[half:] # Sx,Sy,Sz Sx = spins*cos(theta)*cos(phi) Sy = spins*cos(theta)*sin(phi) Sz = spins*sin(theta) # dSx/dtheta,dSy/dtheta,dSz/dtheta Sxt = -spins*sin(theta)*cos(phi) Syt = -spins*sin(theta)*sin(phi) Szt = spins*cos(theta) # dSx/dphi,dSy/dphi,dSz/dphi Sxp = -spins*cos(theta)*sin(phi) Syp = spins*cos(theta)*cos(phi) Szp = 0*cos(theta) # Makes an array of the derivatives with respect to theta, then another with respect to phi # (dSx1/dtheta1,dSy1/dtheta1,dSz1/dtheta1 # ( dSx2/dtheta2,dSy2/dtheta2,dSz2/dtheta2 # ( ... # Similarly for phis # Then we multiply this by Jij which yields a half by 3*half array. We then multiply this by # the Sij vector which finally yields a half by 1 array. Thus # dSijt * Jij * Sij -> [dE/dtheta1, dE/dtheta2, dE/dtheta3, ...] # and similarly for phi dSijt = np.zeros((half,3*half)) dSijp = np.zeros((half,3*half)) dSijt[range(half),range(0,3*half,3)]=Sxt dSijt[range(half),range(1,3*half,3)]=Syt dSijt[range(half),range(2,3*half,3)]=Szt dSijp[range(half),range(0,3*half,3)]=Sxp dSijp[range(half),range(1,3*half,3)]=Syp dSijp[range(half),range(2,3*half,3)]=Szp # Standard Sij spin vector we've been using Sij = np.array([Sx,Sy,Sz]) Sij = Sij.T.reshape(1,3*len(p)//2).T # Calculate a hamiltonian for both theta and phi res1t = dSijt * Jij Hijt = np.dot(res1t,Sij) Hamt = - Hijt - np.matrix(np.dot((dSijt**2),anis)).T res1p = dSijp * Jij Hijp = np.dot(res1p,Sij) Hamp = - Hijp - np.matrix(np.dot((dSijp**2),anis)).T #rest = calculate_Ham(Sij,anis,Jij,dsij = dSijt) #resp = calculate_Ham(Sij,anis,Jij,dsij = dSijp) # Concatenate the two and return the result result = np.concatenate((np.array(Hamt),np.array(Hamp))) return result.T # populate initial p list # returns a numpy array of all the thetas followed by all the phis thetas = [] phis = [] for i in range(N_atoms): sx = atom_list[i].spin[0] sy = atom_list[i].spin[1] sz = atom_list[i].spin[2] s = atom_list[i].spinMagnitude theta = arcsin(sz/s) phi = np.arctan2(sy,sx) thetas.append(theta) phis.append(phi) p0 = np.array(thetas+phis) # define the limits parameter list limits = [] for i in range(len(p0)): if i < len(p0)//2:#theta limits.append((-pi,pi)) else:#phi limits.append((0,pi)) # call minimizing function m = fmin_l_bfgs_b(hamiltonian, p0, fprime = deriv, args = (Jij, spin_mags, anis), bounds = limits) # grab returned parameters # thetas are the first half of the list, phis are the second half pout=m[0] theta=pout[0:len(pout)/2] phi=pout[len(pout)/2::] # recreate sx,sy,sz's sx=spin_mags*cos(theta)*cos(phi) sy=spin_mags*cos(theta)*sin(phi) sz=spin_mags*sin(theta) # return spin vector array return np.array([sx,sy,sz]).T
def local_optimizer(interfile, spinfile): """ Given an interaction file and a spin file, this optimizer will uses readfiles.readfiles to populate an atom list as well as return the interaction matrices. Given that information, it will recalculate the hamiltonian and attempt to minimize it as a function of theta and phi. The annealing will get the spins close to the global minimum and this method makes sure the spins are aligned. This routine uses only python instead of C. """ # Get atoms list, jmats from the interaction and spin files atom_list, jnums, jmats, N_atoms_uc = rf.readFiles(interfile, spinfile, allAtoms=True) N_atoms = len(atom_list) # Generate the Jij and anisotropy arrays Jij = gen_Jij(atom_list, jmats) anis = gen_anisotropy(atom_list) # Get the spin magnitudes from the atoms in atom list spin_mags = [] for i in range(len(atom_list)): spin_mags.append(atom_list[i].spinMagnitude) spin_mags = np.array(spin_mags) # hamiltonian method def hamiltonian(p, Jij=None, spins=None, anis=None): """ Computes the hamiltonian given a list a thetas and phis""" # Thetas are the first half, phis the second half theta = p[:len(p) // 2] phi = p[len(p) // 2:] # Sx,Sy,Sz Sx = spins * cos(theta) * cos(phi) Sy = spins * cos(theta) * sin(phi) Sz = spins * sin(theta) # Array of spin vectors for each atom. Reshape it. Calculate hamiltonian with it and return the hamiltonian. Sij = np.array([Sx, Sy, Sz]) Sij = Sij.T.reshape(1, 3 * len(p) // 2).T SijT = Sij.T # Normal mode # sij.T * jij * sij res1 = SijT * Jij Hij = np.dot(res1, Sij).flat[0] Ham = -Hij - np.dot(anis, Sij**2) return Ham # derivative of the hamiltonian def deriv(p, Jij=None, spins=None, anis=None): """ Computes the derivative of the hamiltonian with respect to each theta and then each phi""" # Thetas are the first half, phis the second half half = len(p) / 2 theta = p[:half] phi = p[half:] # Sx,Sy,Sz Sx = spins * cos(theta) * cos(phi) Sy = spins * cos(theta) * sin(phi) Sz = spins * sin(theta) # dSx/dtheta,dSy/dtheta,dSz/dtheta Sxt = -spins * sin(theta) * cos(phi) Syt = -spins * sin(theta) * sin(phi) Szt = spins * cos(theta) # dSx/dphi,dSy/dphi,dSz/dphi Sxp = -spins * cos(theta) * sin(phi) Syp = spins * cos(theta) * cos(phi) Szp = 0 * cos(theta) # Makes an array of the derivatives with respect to theta, then another with respect to phi # (dSx1/dtheta1,dSy1/dtheta1,dSz1/dtheta1 # ( dSx2/dtheta2,dSy2/dtheta2,dSz2/dtheta2 # ( ... # Similarly for phis # Then we multiply this by Jij which yields a half by 3*half array. We then multiply this by # the Sij vector which finally yields a half by 1 array. Thus # dSijt * Jij * Sij -> [dE/dtheta1, dE/dtheta2, dE/dtheta3, ...] # and similarly for phi dSijt = np.zeros((half, 3 * half)) dSijp = np.zeros((half, 3 * half)) dSijt[range(half), range(0, 3 * half, 3)] = Sxt dSijt[range(half), range(1, 3 * half, 3)] = Syt dSijt[range(half), range(2, 3 * half, 3)] = Szt dSijp[range(half), range(0, 3 * half, 3)] = Sxp dSijp[range(half), range(1, 3 * half, 3)] = Syp dSijp[range(half), range(2, 3 * half, 3)] = Szp # Standard Sij spin vector we've been using Sij = np.array([Sx, Sy, Sz]) Sij = Sij.T.reshape(1, 3 * len(p) // 2).T # Calculate a hamiltonian for both theta and phi res1t = dSijt * Jij Hijt = np.dot(res1t, Sij) Hamt = -Hijt - np.matrix(np.dot((dSijt**2), anis)).T res1p = dSijp * Jij Hijp = np.dot(res1p, Sij) Hamp = -Hijp - np.matrix(np.dot((dSijp**2), anis)).T #rest = calculate_Ham(Sij,anis,Jij,dsij = dSijt) #resp = calculate_Ham(Sij,anis,Jij,dsij = dSijp) # Concatenate the two and return the result result = np.concatenate((np.array(Hamt), np.array(Hamp))) return result.T # populate initial p list # returns a numpy array of all the thetas followed by all the phis thetas = [] phis = [] for i in range(N_atoms): sx = atom_list[i].spin[0] sy = atom_list[i].spin[1] sz = atom_list[i].spin[2] s = atom_list[i].spinMagnitude theta = arcsin(sz / s) phi = np.arctan2(sy, sx) thetas.append(theta) phis.append(phi) p0 = np.array(thetas + phis) # define the limits parameter list limits = [] for i in range(len(p0)): if i < len(p0) // 2: #theta limits.append((-pi, pi)) else: #phi limits.append((0, pi)) # call minimizing function m = fmin_l_bfgs_b(hamiltonian, p0, fprime=deriv, args=(Jij, spin_mags, anis), bounds=limits) # grab returned parameters # thetas are the first half of the list, phis are the second half pout = m[0] theta = pout[0:len(pout) / 2] phi = pout[len(pout) / 2::] # recreate sx,sy,sz's sx = spin_mags * cos(theta) * cos(phi) sy = spin_mags * cos(theta) * sin(phi) sz = spin_mags * sin(theta) # return spin vector array return np.array([sx, sy, sz]).T
def run_cross_section(interactionfile, spinfile): start = clock() # Generate Inputs atom_list, jnums, jmats, N_atoms_uc = readFiles(interactionfile, spinfile) atom1 = atom(pos=[0.00, 0, 0], neighbors=[1], interactions=[0], int_cell=[0], atomicNum=26, valence=3) atom2 = atom(pos=[0.25, 0, 0], neighbors=[0, 2], interactions=[0], int_cell=[0], atomicNum=26, valence=3) atom3 = atom(pos=[0.50, 0, 0], neighbors=[1, 3], interactions=[0], int_cell=[0], atomicNum=26, valence=3) atom4 = atom(pos=[0.75, 0, 0], neighbors=[2], interactions=[0], int_cell=[0], atomicNum=26, valence=3) # atom_list,N_atoms_uc = ([atom1, atom2, atom3, atom4],1) N_atoms = len(atom_list) print N_atoms if 1: kx = sp.Symbol('kx', real=True, commutative=True) ky = sp.Symbol('ky', real=True, commutative=True) kz = sp.Symbol('kz', real=True, commutative=True) k = spm.Matrix([kx, ky, kz]) (b, bd) = generate_b_bd_operators(atom_list) # list_print(b) (a, ad) = generate_a_ad_operators(atom_list, k, b, bd) list_print(a) (Sp, Sm) = generate_Sp_Sm_operators(atom_list, a, ad) list_print(Sp) (Sa, Sb, Sn) = generate_Sa_Sb_Sn_operators(atom_list, Sp, Sm) # list_print(Sa) (Sx, Sy, Sz) = generate_Sx_Sy_Sz_operators(atom_list, Sa, Sb, Sn) list_print(Sx) print '' #Ham = generate_Hamiltonian(N_atoms, atom_list, b, bd) ops = generate_possible_combinations(atom_list, [Sx, Sy, Sz]) # list_print(ops) ops = holstein(atom_list, ops) # list_print(ops) ops = apply_commutation(atom_list, ops) # list_print(ops) ops = replace_bdb(atom_list, ops) # list_print(ops) ops = reduce_options(atom_list, ops) list_print(ops) # Old Method #cross_sect = generate_cross_section(atom_list, ops, 1, real, recip) #print '\n', cross_sect if 1: aa = bb = cc = np.array([2.0 * np.pi], 'Float64') alpha = beta = gamma = np.array([np.pi / 2.0], 'Float64') vect1 = np.array([[1, 0, 0]]) vect2 = np.array([[0, 0, 1]]) lattice = Lattice(aa, bb, cc, alpha, beta, gamma, Orientation(vect1, vect2)) data = {} data['kx'] = 1. data['ky'] = 0. data['kz'] = 0. direction = data temperature = 100.0 min = 0 max = 2 * sp.pi steps = 25 tau_list = [] for i in range(1): tau_list.append(np.array([0, 0, 0], 'Float64')) h_list = np.linspace(0, 2, 100) k_list = np.zeros(h_list.shape) l_list = np.zeros(h_list.shape) w_list = np.linspace(-4, 4, 100) efixed = 14.7 #meV eief = True eval_cross_section(interactionfile, spinfile, lattice, ops, tau_list, h_list, k_list, l_list, w_list, data, temperature, min, max, steps, eief, efixed) end = clock() print "\nFinished %i atoms in %.2f seconds" % (N_atoms, end - start)
atom_list, jnums, jmats, N_atoms_uc = rf.readFiles(interfile,spinfile,allAtoms=True) N_atoms = len(atom_list) jij = gen_Jij(atom_list,jmats) anis = gen_anisotropy(atom_list) sij = gen_spinVector(atom_list) Ham = calculate_Ham(sij, anis, jij) return local_optimizer(interfile, spinfile) if __name__ == '__main__': #print optimizeSpins('C:\\export.txt', 'C:\\spins.txt', 'C:\\spins2.txt') #interfile = 'c:/test_montecarlo.txt' #spinfile = 'c:/test_Spins.txt' interfile='c:/montecarlo_ferro.txt' spinfile='c:/Spins_ferro.txt' atom_list, jnums, jmats,N_atoms_uc=rf.readFiles(interfile,spinfile,allAtoms=True) N_atoms = len(atom_list) jij = gen_Jij(atom_list, jmats) anis = gen_anisotropy(atom_list) sij = gen_spinVector(atom_list) Ham = calculate_Ham(sij, anis, jij) print Ham print local_optimizer(interfile, spinfile)
N_atoms_uc,csection,kaprange,tau_list,eig_list,kapvect,wt_list,fflist = run_cross_section(interfile,spinfile) x,y,z=run_spherical_averaging(N_atoms_uc,atom_list,rad,csection,kapvect,tau_list,eig_list,wt_list,temperature) np.save(os.path.join(file_pathname,r'myfilex.txt'),x) np.save(os.path.join(file_pathname,r'myfiley.txt'),y) np.save(os.path.join(file_pathname,r'myfilez.txt'),z) if __name__=='__main__': #def pd(): #from spinwaves.cross_section.csection_calc import spherical_averaging as sph file_pathname = os.path.abspath('') interfile = os.path.join(file_pathname,r'montecarlo.txt') spinfile = os.path.join(file_pathname,r'spins.txt') atom_list, jnums, jmats,N_atoms_uc=readFiles(interfile,spinfile) N_atoms_uc,csection,kaprange,tau_list,eig_list,kapvect,wt_list,fflist = run_cross_section(interfile,spinfile) # left_conn, right_conn = Pipe() # p = Process(target = create_latex, args = (right_conn, csection, "Cross-Section")) # p.start() # eig_frame = LaTeXDisplayFrame(self.parent, p.pid, left_conn.recv(), 'Cross-Section') # self.process_list.append(p) # p.join() # p.terminate() # ORIGINAL METHOD TO GENERATE CROSS SECTION if 0: kapvect,wt_list,csdata=run_eval_cross_section(N_atoms_uc,csection,kaprange,tau_list,eig_list,kapvect,wt_list,fflist) plot_cross_section(kapvect[:,0],wt_list,csdata)
def eval_cross_section(interactionfile, spinfile, lattice, arg, tau_list, h_list, k_list, l_list, w_vect_list, direction, temperature, kmin, kmax, steps, eief, efixed=14.7): """ Calculates the cross_section given the following parameters: interactionfile, spinfile - files to get atom data lattice - Lattice object from tripleaxisproject arg - reduced list of operator combinations tau_list - list of tau position w_list - list of w's probed direction - direction of scan temp - temperature kmin - minimum value of k to scan kmax - maximum value of k to scan steps - number of steps between kmin, kmax eief - True if the energy scheme is Ei - Ef, False if it is Ef - Ei efixed - value of the fixed energy, either Ei or Ef """ # Read files, get atom_list and such atom_list, jnums, jmats, N_atoms_uc = readFiles(interactionfile, spinfile) N_atoms = len(atom_list) N = N_atoms # TEMPORARY TO OVERRIDE ATOM_LIST ABOVE # atom1 = atom(pos = [0.00,0,0], neighbors = [1], interactions = [0], int_cell = [0], # atomicNum = 26, valence = 3, spinRmatrix=spm.Matrix([[1, 0, 0],[0, 1, 0],[0, 0, 1]])) # atom2 = atom(pos = [0.25,0,0], neighbors = [0,2], interactions = [0], int_cell = [0], # atomicNum = 26, valence = 3, spinRmatrix=spm.Matrix([[1, 0, 0],[0, 1, 0],[0, 0, 1]])) # atom3 = atom(pos = [0.50,0,0], neighbors = [1,3], interactions = [0], int_cell = [0], # atomicNum = 26, valence = 3, spinRmatrix=spm.Matrix([[1, 0, 0],[0, 1, 0],[0, 0, 1]])) # atom4 = atom(pos = [0.75,0,0], neighbors = [2], interactions = [0], int_cell = [0], # atomicNum = 26, valence = 3, spinRmatrix=spm.Matrix([[1, 0, 0],[0, 1, 0],[0, 0, 1]])) # atom_list,N_atoms_uc = ([atom1, atom2, atom3, atom4],1) N_atoms = len(atom_list) # Get Hsave to calculate its eigenvalues (Hsave, charpoly, eigs) = calculate_dispersion(atom_list, N_atoms_uc, N_atoms, jmats, showEigs=True) print "Calculated: Dispersion Relation" # Generate kappa's from (h,k,l) kaprange = [] kapvect = [] if len(h_list) == len(k_list) == len(l_list): for i in range(len(h_list)): kappa = lattice.modvec(h_list[i], k_list[i], l_list[i], 'latticestar') kaprange.append(kappa[0]) kapvect.append(np.array([h_list[i], k_list[i], l_list[i]])) # kapvect.append(np.array([h_list[i]/kappa,k_list[i]/kappa,l_list[i]/kappa])) else: raise Exception('h,k,l not same lengths') # Generate q's from kappa and tau pqrange = [] mqrange = [] for tau in tau_list: ptemp = [] mtemp = [] for kap in kapvect: #tau = lattice.modvec(tau[0],tau[1],tau[2], 'latticestar') ptemp.append(kap - tau) mtemp.append(tau - kap) pqrange.append(ptemp) mqrange.append(mtemp) # Calculate w_q's using q qrange = [] # krange = [] wrange = [] if 1: # Change this later for set in pqrange: temp = [] temp1 = [] for q in set: eigs = calc_eigs(Hsave, q[0] * direction['kx'], q[1] * direction['ky'], q[2] * direction['kz']) # Take only one set of eigs. Should probably have a flag here. temp.append(eigs[0]) # krange.append(np.array([q*direction['kx'], q*direction['ky'], q*direction['kz']])) temp1.append(q) wrange.append(temp) qrange.append(temp1) print "Calculated: Eigenvalues" wrange = np.array(np.real(wrange)) qrange = np.array(np.real(qrange)) kaprange = np.array(np.real(kaprange)) print qrange.shape print wrange.shape print kaprange.shape # Calculate w (not _q) as well as kp/k w_calc = [] kpk = [] if eief == True: for tau in tau_list: temp = [] temp1 = [] for om in w_vect_list: temp.append(om - efixed) temp1.append(np.sqrt(om / efixed)) w_calc.append(temp) kpk.append(temp1) else: for tau in tau_list: temp = [] temp1 = [] for om in w_vect_list: temp.append(-(om - efixed)) temp1.append(np.sqrt(efixed / om)) w_calc.append(temp) kpk.append(temp1) w_calc = np.array(np.real(w_calc)) # Grab Form Factors ff_list = [] s = sp.Symbol('s') for i in range(N_atoms): el = elements[atom_list[i].atomicNum] val = atom_list[i].valence if val != None: Mq = el.magnetic_ff[val].M_Q(kaprange) else: Mq = el.magnetic_ff[0].M_Q(kaprange) ff_list.append(Mq) print "Calculated: Form Factors" # Other Constants gamr0 = 2 * 0.2695 * 10**(-12) #sp.Symbol('gamma', commutative = True) hbar = 1.0 # 1.05457148*10**(-34) #sp.Symbol('hbar', commutative = True) g = 2. #sp.Symbol('g', commutative = True) # Kappa vector kap = sp.Symbol( 'kappa', real=True ) #spm.Matrix([sp.Symbol('kapx',real = True),sp.Symbol('kapy',real = True),sp.Symbol('kapz',real = True)]) t = sp.Symbol('t', real=True) w = sp.Symbol('w', real=True) W = sp.Symbol('W', real=True) tau = sp.Symbol('tau', real=True) q = sp.Symbol('q', real=True) L = sp.Symbol('L', real=True) boltz = 1. #1.3806503*10**(-23) # Wilds for sub_in method A = sp.Wild('A', exclude=[0, t]) B = sp.Wild('B', exclude=[0, t]) C = sp.Wild('C') D = sp.Wild('D') K = sp.Wild('K') # First the exponentials are turned into delta functions: for i in range(len(arg)): for j in range(N): print '1', arg[i][j] arg[i][j] = sp.powsimp( arg[i] [j]) #sp.powsimp(arg[i][j], deep = True, combine = 'all') arg[i][j] = ( arg[i][j] * exp(-I * w * t) * exp(I * kap * L)).expand( ) # * exp(I*inner_prod(spm.Matrix(atom_list[j].pos).T,kap)) arg[i][j] = sp.powsimp( arg[i] [j]) #sp.powsimp(arg[i][j], deep = True, combine = 'all') # print '2', arg[i][j] arg[i][j] = sub_in( arg[i][j], exp(I * t * A + I * t * B + I * C + I * D + I * K), sp.DiracDelta(A * t + B * t + C + D + K)) #*sp.DiracDelta(C)) # print '3', arg[i][j] arg[i][j] = sub_in( arg[i][j], sp.DiracDelta(A * t + B * t + C * L + D * L + K * L), sp.DiracDelta(A * hbar + B * hbar) * sp.simplify(sp.DiracDelta(C + D + K + tau))) # print '4', arg[i][j] arg[i][j] = sub_in(arg[i][j], sp.DiracDelta(-A - B) * sp.DiracDelta(C), sp.DiracDelta(A + B) * sp.DiracDelta(C)) print '5', arg[i][j] print "Applied: Delta Function Conversion" # Grabs the unit vectors from the back of the lists. unit_vect = [] kapxhat = sp.Symbol('kapxhat', commutative=False) kapyhat = sp.Symbol('kapyhat', commutative=False) kapzhat = sp.Symbol('kapzhat', commutative=False) for i in range(len(arg)): unit_vect.append(arg[i].pop()) # Subs the actual values for kx,ky,kz, omega_q and n_q into the operator combos # The result is basically a nested list: # # csdata = [ op combos ] # op combos = [ one combo per atom ] # 1 per atom = [ evaluated exp ] # csdata = [] for i in range(len(arg)): temp1 = [] for j in range(len(arg[i])): temp2 = [] for k in range(len(tau_list)): temp3 = [] print i, j, k for g in range(len(qrange[k])): pvalue = tau_list[k] + kapvect[g] + qrange[k][g] mvalue = tau_list[k] + kapvect[g] - qrange[k][g] if pvalue[0] == 0 and pvalue[1] == 0 and pvalue[2] == 0: arg[i][j] = arg[i][j].subs( sp.DiracDelta(kap + tau + q), sp.DiracDelta(0)) else: arg[i][j] = arg[i][j].subs( sp.DiracDelta(kap + tau + q), 0) if mvalue[0] == 0 and mvalue[1] == 0 and mvalue[2] == 0: arg[i][j] = arg[i][j].subs( sp.DiracDelta(kap + tau - q), sp.DiracDelta(0)) else: arg[i][j] = arg[i][j].subs( sp.DiracDelta(kap + tau - q), 0) wq = sp.Symbol('wq', real=True) nq = sp.Symbol('n%i' % (k, ), commutative=False) arg[i][j] = arg[i][j].subs(wq, wrange[k][g]) arg[i][j] = arg[i][j].subs(w, w_calc[k][g]) n = sp.Pow( sp.exp(hbar * wrange[k][g] / boltz * temperature) - 1, -1) arg[i][j] = arg[i][j].subs(nq, n) temp3.append(arg[i][j]) temp2.append(temp3) temp1.append(temp2) csdata.append(temp1) ## print arg[i][j] # for g in range(len(kaprange)): # arg[i][j] = arg[i][j].subs(kap, kaprange[g]) # for g in range(len(krange)): ## print 'calculating' # temp3 = [] # wg = sp.Symbol('w%i'%(g,), real = True) # ng = sp.Symbol('n%i'%(g,), commutative = False) ## kx = sp.Symbol('kx', real = True, commutative = True) ## ky = sp.Symbol('ky', real = True, commutative = True) ## kz = sp.Symbol('kz', real = True, commutative = True) ## arg[i][j] = arg[i][j].subs(kx,krange[g][0]) ## arg[i][j] = arg[i][j].subs(ky,krange[g][1]) ## arg[i][j] = arg[i][j].subs(kz,krange[g][2]) # arg[i][j] = arg[i][j].subs(wg,wrange[g]) # arg[i][j] = arg[i][j].subs(w,w_calc[g]) # nq = sp.Pow( sp.exp(hbar*wrange[g]/boltz*temp) - 1 ,-1) # arg[i][j] = arg[i][j].subs(ng,nq) ## arg[i][j] = arg[i][j].subs(tau,tau_list[0]) # # temp3.append(arg[i][j]) ## print arg[i][j] # temp2.append(temp3) ## print arg[i][j] # csdata.append(temp2) print csdata # Front constants and stuff for the cross-section front_constant = 1.0 # (gamr0)**2/(2*pi*hbar) front_func = (1. / 2.) * g #*F(k) vanderwaals = 1. #exp(-2*W) csrange = [] if 1: temp1 = [] temp2 = [] for q in range(len(qrange)): print 'calculating' for ii in range(len(csdata)): for jj in range(len(csdata[ii])): temp1.append(csdata[ii][jj]) # Put on gamr0, 2pi hbar, form factor, kp/k, vanderwaals first dif = front_func**2 * front_constant # * kpk[q][0] * vanderwaals * ff_list[0][q] # for vect in unit_vect: # vect.subs(kapxhat,kapvect[q][0][0]) # vect.subs(kapyhat,kapvect[q][1][0]) # vect.subs(kapzhat,kapvect[q][2][0]) print 'diff', dif print 'temp1', temp1 print sum(temp1) dif = (dif * sum(temp1)) # * sum(unit_vect))#.expand() csrange.append(dif) print "Calculated: Cross-section" csrange = np.real(csrange) csrange = np.array(csrange) xi = qrange yi = wrange zi = csrange Z = np.zeros((xi.shape[0], yi.shape[0])) Z[range(len(xi)), range(len(yi))] = zi pylab.contourf(xi, yi, Z) pylab.colorbar() pylab.show()
def generate_cross_section(interactionfile, spinfile, lattice, arg, tau_list, h_list, k_list, l_list, w_list, temperature, steps, eief, efixed = 14.7): """ Calculates the cross_section given the following parameters: interactionfile, spinfile - files to get atom data lattice - Lattice object from tripleaxisproject arg - reduced list of operator combinations tau_list - list of tau position w_list - list of w's probed temp - temperature kmin - minimum value of k to scan kmax - maximum value of k to scan steps - number of steps between kmin, kmax eief - True if fixed Ef efixed - value of the fixed energy, either Ei or Ef """ # Read files, get atom_list and such atom_list, jnums, jmats,N_atoms_uc=readFiles(interactionfile,spinfile) # Get Hsave to calculate its eigenvalues N_atoms = len(atom_list) Hsave = calculate_dispersion(atom_list,N_atoms_uc,N_atoms,jmats,showEigs=False) atom_list=atom_list[:N_atoms_uc] N_atoms = len(atom_list) N = N_atoms print "Calculated: Dispersion Relation" # Generate kappa's from (h,k,l) kaprange = [] kapvect = [] #if len(h_list) == len(k_list) == len(l_list): #for i in range(len(h_list)): #kappa = lattice.modvec(h_list[i],k_list[i],l_list[i], 'latticestar') #kaprange.append(kappa[0]) #kapvect.append(np.array([h_list[i],k_list[i],l_list[i]])) ## kapvect.append(np.array([h_list[i]/kappa,k_list[i]/kappa,l_list[i]/kappa])) #else: #raise Exception('h,k,l not same lengths') # Generate q's from kappa and tau kaprange=lattice.modvec(h_list,k_list,l_list, 'latticestar') nkpts=len(kaprange) kapvect=np.empty((nkpts,3),'Float64') kapvect[:,0]=h_list kapvect[:,1]=k_list kapvect[:,2]=l_list # print kapvect.shape # print kaprange.shape kapunit = kapvect.copy() kapunit[:,0]=kapvect[:,0]/kaprange kapunit[:,1]=kapvect[:,1]/kaprange kapunit[:,2]=kapvect[:,2]/kaprange #plusq=kappa-tau plusq=[] minusq=[] qlist=[] ones_list=np.ones((1,nkpts),'Float64') #wtlist=np.ones((1,nkpts*2),'Float64').flatten() wtlist=np.hstack([w_list,w_list]) #weven=np.array(range(0,nkpts*2,2)) #wodd=np.array(range(1,nkpts*2,2)) #wtlist[wodd]=w_list #wtlist[weven]=w_list qtlist=[] for tau in tau_list: taui=np.ones((nkpts,3),'Float64') taui[:,0]=ones_list*tau[0] taui[:,1]=ones_list*tau[1] taui[:,2]=ones_list*tau[2] kappa_minus_tau=kapvect-taui tau_minus_kappa=taui - kapvect qlist.append(np.vstack([kappa_minus_tau,tau_minus_kappa])) #calculate kfki nqpts=nkpts*2 kfki=calc_kfki(w_list,eief,efixed) eig_list=[] # print qlist for q in qlist: #eigs = calc_eigs_direct(Hsave,q[:,0],q[:,1],q[:,2]) eigs = Hsave.eigenvals().keys() eig_list.append(eigs) print "Calculated: Eigenvalues" # print len(qlist) # print len(eig_list[0]) # sys.exit() # Grab Form Factors #----Commented out 9/14/09 by Tom becuase of magnetic_ff error-------------- #ff_list = [] #s = sp.Symbol('s') #for i in range(N_atoms): #el = elements[atom_list[i].atomicNum] #val = atom_list[i].valence #if val != None: #Mq = el.magnetic_ff[val].M_Q(kaprange) #else: #Mq = el.magnetic_ff[0].M_Q(kaprange) #ff_list.append(Mq) #print "Calculated: Form Factors" #-------------------------------------------------------------------------- # Other Constants gamr0 = 2*0.2695e-12 #sp.Symbol('gamma', commutative = True) hbar = sp.S(1.0) # 1.05457148*10**(-34) #sp.Symbol('hbar', commutative = True) g = 2.#sp.Symbol('g', commutative = True) # Kappa vector kap = sp.Symbol('kappa', real = True)#spm.Matrix([sp.Symbol('kapx',real = True),sp.Symbol('kapy',real = True),sp.Symbol('kapz',real = True)]) t = sp.Symbol('t', real = True) w = sp.Symbol('w', real = True) W = sp.Symbol('W', real = True) tau = sp.Symbol('tau', real = True) Q = sp.Symbol('q', real = True) L = sp.Symbol('L', real = True) lifetime=sp.Symbol('V',real=True) boltz = 8.617343e-2 # Wilds for sub_in method A = sp.Wild('A',exclude = [0,t]) B = sp.Wild('B',exclude = [0,t]) C = sp.Wild('C') D = sp.Wild('D') K = sp.Wild('K') # Grabs the unit vectors from the back of the lists. unit_vect = [] kapxhat = sp.Symbol('kapxhat',real=True) kapyhat = sp.Symbol('kapyhat',real=True) kapzhat = sp.Symbol('kapzhat',real=True) for i in range(len(arg)): unit_vect.append(arg[i].pop()) #print unit_vect unit_vect = sum(unit_vect) print unit_vect csection=0 for i in range(len(arg)): for j in range(len(arg[i])): csection=csection+arg[i][j]*unit_vect print csection csection=sp.powsimp(csection) csection = (csection * exp(-I*w*t) * exp(I*kap*L)).expand(deep = False) print 'intermediate' #print csection csection= sp.powsimp(csection) csection = sub_in(csection,exp(I*t*A + I*t*B + I*C + I*D + I*K),sp.DiracDelta(A*t + B*t + C + D + K)) csection = sub_in(csection,sp.DiracDelta(A*t + B*t + C*L + D*L ),sp.DiracDelta(A*hbar + B*hbar)*sp.simplify(sp.DiracDelta(C + D - tau))) #This is correct #csection = sub_in(csection,sp.DiracDelta(A*t + B*t + C*L + D*L ),sp.simplify(lifetime*sp.DiracDelta(C + D - tau)* #sp.Pow((A-B)**2+lifetime**2,-1))) print "Applied: Delta Function Conversion" # print csection print 'done' ## First the exponentials are turned into delta functions: #for i in range(len(arg)): #for j in range(N): ## print '1', arg[i][j] #arg[i][j] = sp.powsimp(arg[i][j])#sp.powsimp(arg[i][j], deep = True, combine = 'all') #arg[i][j] = (arg[i][j] * exp(-I*w*t) * exp(I*kap*L)).expand()# * exp(I*inner_prod(spm.Matrix(atom_list[j].pos).T,kap)) #arg[i][j] = sp.powsimp(arg[i][j])#sp.powsimp(arg[i][j], deep = True, combine = 'all') ## print '2', arg[i][j] #arg[i][j] = sub_in(arg[i][j],exp(I*t*A + I*t*B + I*C + I*D + I*K),sp.DiracDelta(A*t + B*t + C + D + K))#*sp.DiracDelta(C)) ## print '3', arg[i][j] #arg[i][j] = sub_in(arg[i][j],sp.DiracDelta(A*t + B*t + C*L + D*L + K*L),sp.DiracDelta(A*hbar + B*hbar)*sp.simplify(sp.DiracDelta(C + D + K + tau))) ## print '4', arg[i][j] #arg[i][j] = sub_in(arg[i][j],sp.DiracDelta(-A - B)*sp.DiracDelta(C),sp.DiracDelta(A + B)*sp.DiracDelta(C)) ## arg[i][j] = arg[i][j].subs(-w - wq, w + wq) ## print '5', arg[i][j] print "Applied: Delta Function Conversion" # Subs the actual values for kx,ky,kz, omega_q and n_q into the operator combos # The result is basically a nested list: # # csdata = [ op combos ] # op combos = [ one combo per atom ] # 1 per atom = [ evaluated exp ] # csection=sub_in(csection,sp.DiracDelta(-A - B)*sp.DiracDelta(C),sp.DiracDelta(A + B)*sp.DiracDelta(C)) print "end part 1" #print csection return (N_atoms_uc, csection, kaprange, qlist, tau_list, eig_list, kapvect, wtlist)
def generate_cross_section(interactionfile, spinfile, lattice, arg, tau_list, h_list, k_list, l_list, w_list, temperature, steps, eief, efixed=14.7): """ Calculates the cross_section given the following parameters: interactionfile, spinfile - files to get atom data lattice - Lattice object from tripleaxisproject arg - reduced list of operator combinations tau_list - list of tau position w_list - list of w's probed temp - temperature kmin - minimum value of k to scan kmax - maximum value of k to scan steps - number of steps between kmin, kmax eief - True if fixed Ef efixed - value of the fixed energy, either Ei or Ef """ # Read files, get atom_list and such atom_list, jnums, jmats, N_atoms_uc = readFiles(interactionfile, spinfile) # Get Hsave to calculate its eigenvalues N_atoms = len(atom_list) Hsave = calculate_dispersion(atom_list, N_atoms_uc, N_atoms, jmats, showEigs=False) atom_list = atom_list[:N_atoms_uc] N_atoms = len(atom_list) N = N_atoms print "Calculated: Dispersion Relation" # Generate kappa's from (h,k,l) kaprange = [] kapvect = [] #if len(h_list) == len(k_list) == len(l_list): #for i in range(len(h_list)): #kappa = lattice.modvec(h_list[i],k_list[i],l_list[i], 'latticestar') #kaprange.append(kappa[0]) #kapvect.append(np.array([h_list[i],k_list[i],l_list[i]])) ## kapvect.append(np.array([h_list[i]/kappa,k_list[i]/kappa,l_list[i]/kappa])) #else: #raise Exception('h,k,l not same lengths') # Generate q's from kappa and tau kaprange = lattice.modvec(h_list, k_list, l_list, 'latticestar') nkpts = len(kaprange) kapvect = np.empty((nkpts, 3), 'Float64') kapvect[:, 0] = h_list kapvect[:, 1] = k_list kapvect[:, 2] = l_list # print kapvect.shape # print kaprange.shape kapunit = kapvect.copy() kapunit[:, 0] = kapvect[:, 0] / kaprange kapunit[:, 1] = kapvect[:, 1] / kaprange kapunit[:, 2] = kapvect[:, 2] / kaprange #plusq=kappa-tau plusq = [] minusq = [] qlist = [] ones_list = np.ones((1, nkpts), 'Float64') #wtlist=np.ones((1,nkpts*2),'Float64').flatten() wtlist = np.hstack([w_list, w_list]) #weven=np.array(range(0,nkpts*2,2)) #wodd=np.array(range(1,nkpts*2,2)) #wtlist[wodd]=w_list #wtlist[weven]=w_list qtlist = [] for tau in tau_list: taui = np.ones((nkpts, 3), 'Float64') taui[:, 0] = ones_list * tau[0] taui[:, 1] = ones_list * tau[1] taui[:, 2] = ones_list * tau[2] kappa_minus_tau = kapvect - taui tau_minus_kappa = taui - kapvect qlist.append(np.vstack([kappa_minus_tau, tau_minus_kappa])) #calculate kfki nqpts = nkpts * 2 kfki = calc_kfki(w_list, eief, efixed) eig_list = [] # print qlist for q in qlist: #eigs = calc_eigs_direct(Hsave,q[:,0],q[:,1],q[:,2]) eigs = Hsave.eigenvals().keys() eig_list.append(eigs) print "Calculated: Eigenvalues" # print len(qlist) # print len(eig_list[0]) # sys.exit() # Grab Form Factors #----Commented out 9/14/09 by Tom becuase of magnetic_ff error-------------- #ff_list = [] #s = sp.Symbol('s') #for i in range(N_atoms): #el = elements[atom_list[i].atomicNum] #val = atom_list[i].valence #if val != None: #Mq = el.magnetic_ff[val].M_Q(kaprange) #else: #Mq = el.magnetic_ff[0].M_Q(kaprange) #ff_list.append(Mq) #print "Calculated: Form Factors" #-------------------------------------------------------------------------- # Other Constants gamr0 = 2 * 0.2695e-12 #sp.Symbol('gamma', commutative = True) hbar = sp.S( 1.0) # 1.05457148*10**(-34) #sp.Symbol('hbar', commutative = True) g = 2. #sp.Symbol('g', commutative = True) # Kappa vector kap = sp.Symbol( 'kappa', real=True ) #spm.Matrix([sp.Symbol('kapx',real = True),sp.Symbol('kapy',real = True),sp.Symbol('kapz',real = True)]) t = sp.Symbol('t', real=True) w = sp.Symbol('w', real=True) W = sp.Symbol('W', real=True) tau = sp.Symbol('tau', real=True) Q = sp.Symbol('q', real=True) L = sp.Symbol('L', real=True) lifetime = sp.Symbol('V', real=True) boltz = 8.617343e-2 # Wilds for sub_in method A = sp.Wild('A', exclude=[0, t]) B = sp.Wild('B', exclude=[0, t]) C = sp.Wild('C') D = sp.Wild('D') K = sp.Wild('K') # Grabs the unit vectors from the back of the lists. unit_vect = [] kapxhat = sp.Symbol('kapxhat', real=True) kapyhat = sp.Symbol('kapyhat', real=True) kapzhat = sp.Symbol('kapzhat', real=True) for i in range(len(arg)): unit_vect.append(arg[i].pop()) #print unit_vect unit_vect = sum(unit_vect) print unit_vect csection = 0 for i in range(len(arg)): for j in range(len(arg[i])): csection = csection + arg[i][j] * unit_vect print csection csection = sp.powsimp(csection) csection = (csection * exp(-I * w * t) * exp(I * kap * L)).expand(deep=False) print 'intermediate' #print csection csection = sp.powsimp(csection) csection = sub_in(csection, exp(I * t * A + I * t * B + I * C + I * D + I * K), sp.DiracDelta(A * t + B * t + C + D + K)) csection = sub_in( csection, sp.DiracDelta(A * t + B * t + C * L + D * L), sp.DiracDelta(A * hbar + B * hbar) * sp.simplify(sp.DiracDelta(C + D - tau))) #This is correct #csection = sub_in(csection,sp.DiracDelta(A*t + B*t + C*L + D*L ),sp.simplify(lifetime*sp.DiracDelta(C + D - tau)* #sp.Pow((A-B)**2+lifetime**2,-1))) print "Applied: Delta Function Conversion" # print csection print 'done' ## First the exponentials are turned into delta functions: #for i in range(len(arg)): #for j in range(N): ## print '1', arg[i][j] #arg[i][j] = sp.powsimp(arg[i][j])#sp.powsimp(arg[i][j], deep = True, combine = 'all') #arg[i][j] = (arg[i][j] * exp(-I*w*t) * exp(I*kap*L)).expand()# * exp(I*inner_prod(spm.Matrix(atom_list[j].pos).T,kap)) #arg[i][j] = sp.powsimp(arg[i][j])#sp.powsimp(arg[i][j], deep = True, combine = 'all') ## print '2', arg[i][j] #arg[i][j] = sub_in(arg[i][j],exp(I*t*A + I*t*B + I*C + I*D + I*K),sp.DiracDelta(A*t + B*t + C + D + K))#*sp.DiracDelta(C)) ## print '3', arg[i][j] #arg[i][j] = sub_in(arg[i][j],sp.DiracDelta(A*t + B*t + C*L + D*L + K*L),sp.DiracDelta(A*hbar + B*hbar)*sp.simplify(sp.DiracDelta(C + D + K + tau))) ## print '4', arg[i][j] #arg[i][j] = sub_in(arg[i][j],sp.DiracDelta(-A - B)*sp.DiracDelta(C),sp.DiracDelta(A + B)*sp.DiracDelta(C)) ## arg[i][j] = arg[i][j].subs(-w - wq, w + wq) ## print '5', arg[i][j] print "Applied: Delta Function Conversion" # Subs the actual values for kx,ky,kz, omega_q and n_q into the operator combos # The result is basically a nested list: # # csdata = [ op combos ] # op combos = [ one combo per atom ] # 1 per atom = [ evaluated exp ] # csection = sub_in(csection, sp.DiracDelta(-A - B) * sp.DiracDelta(C), sp.DiracDelta(A + B) * sp.DiracDelta(C)) print "end part 1" #print csection return (N_atoms_uc, csection, kaprange, qlist, tau_list, eig_list, kapvect, wtlist)
def mcQueeny_case(interactionfile, spinfile, tau_list, temperature, direction={'kx':1,'ky':0,'kz':0}, hkl_interval=[1e-3,2*np.pi,100], omega_interval=[0,5,100], eig_eps = 0.001): initial_time = time.clock() atom_list, jnums, jmats, N_atoms_uc, numCutOff, magCellSize = readFiles(interactionfile,spinfile, rtn_cutOffInfo = True) h_list, k_list, l_list = generate_hkl(hkl_interval, direction) e = generate_wt(omega_interval) ff_list = generate_form_factors(N_atoms_uc, atom_list, hkl_interval) s = [] basis = [] for a in atom_list: s.append(a.spin[2])#z component of spin (assume aligned with z) basis.append(a.pos - magCellSize) #translate back to 0,0,0 mesh = np.zeros((len(h_list), len(e))) for Qindex in range(len(h_list)): Q = (np.array([h_list,k_list,l_list]).transpose())[Qindex] M = create_matrix(atom_list, jnums, jmats, numCutOff, magCellSize, Q-np.array(tau_list)) w, evec = np.linalg.eig(M) ff = ff_list[Qindex] numAtoms = numCutOff evec2 = evec.copy() T = evec sigma = [] for i in range(numAtoms): sigma.append(s[i]/np.abs(s[i])) for n in range(numAtoms): norm = 0 for i in range(numAtoms): norm += sigma[i]*(np.abs(evec2[n][i])**2) for i in range(numAtoms): T[n][i] = evec2[n][i]/np.sqrt(np.abs(norm)) evec = T strfac = np.zeros(numAtoms) ff = 1 for i in range(numAtoms): dum = 0 for j in range(numAtoms): dum += (s[j]/np.sqrt(np.abs(s[j]))) * ff * evec[j][i] #* np.exp(1.0j* exp = np.exp(1.0j*(-Q[0]*basis[j][0] -Q[1]*basis[j][1] -Q[2]*basis[j][2])) strfac[i] = np.abs(dum)**2 sqw = np.zeros(len(e)) for j in range(numAtoms): for i in range(len(e)): y = LIFETIME_VALUE/2 lorentzian = (1/np.pi)*y/((e[i]- w[j])**2+y**2) sqw[i] = sqw[i] + strfac[j] * lorentzian #he has some 'bose' factor in here mesh[Qindex] = sqw #* 0.5*(1 + Q[0]**2) #along x, Q_hat is just 1? print "Run Time: ", time.clock()-initial_time, " seconds"
def mcQueeny_case(interactionfile, spinfile, tau_list, temperature, direction={ 'kx': 1, 'ky': 0, 'kz': 0 }, hkl_interval=[1e-3, 2 * np.pi, 100], omega_interval=[0, 5, 100], eig_eps=0.001): initial_time = time.clock() #to plot eigenvector components # q1 = [] # q2 = [] #to plot w's #w1_list = [] #w2_list = [] #w3_list = [] #w4_list = [] #w5_list = [] #w6_list = [] #w7_list = [] #w8_list = [] # w_output_list = [] #plot the structure factor to compare with lovesey (In McQueeny Paper) # strfac_sums = [] # strfac1 = [] # strfac2 = [] atom_list, jnums, jmats, N_atoms_uc, numCutOff, magCellSize = readFiles( interactionfile, spinfile, rtn_cutOffInfo=True) #Hardcoding body-center cubic if 0: atom_list = [] jnums = [0] N_atom_uc = 1 numCutOff = 7 magCellSize = np.array([1, 1, 1]) jmats = [np.array([[-1, 0, 0], [0, -1, 0], [0, 0, -1]])] atom_list.append( atom(pos=np.array([0.5, 0.5, 0.5]), spin=np.array([0, 0, 1]), interactions=[0, 0, 0, 0, 0, 0], neighbors=[1, 2, 3, 4, 5, 6])) atom_list.append( atom(pos=np.array([0., 0., 0.]), spin=np.array([0, 0, -1]), interactions=[0], neighbors=[0])) atom_list.append( atom(pos=np.array([1., 0., 0.]), spin=np.array([0, 0, -1]), interactions=[0], neighbors=[0])) atom_list.append( atom(pos=np.array([1., 1., 0.]), spin=np.array([0, 0, -1]), interactions=[0], neighbors=[0])) atom_list.append( atom(pos=np.array([1., 0., 1.]), spin=np.array([0, 0, -1]), interactions=[0], neighbors=[0])) atom_list.append( atom(pos=np.array([1., 1., 1.]), spin=np.array([0, 0, -1]), interactions=[0], neighbors=[0])) atom_list.append( atom(pos=np.array([0., 1., 0.]), spin=np.array([0, 0, -1]), interactions=[0], neighbors=[0])) atom_list.append( atom(pos=np.array([0., 0., 1.]), spin=np.array([0, 0, -1]), interactions=[0], neighbors=[0])) atom_list.append( atom(pos=np.array([0., 1., 1.]), spin=np.array([0, 0, -1]), interactions=[0], neighbors=[0])) h_list, k_list, l_list = generate_hkl(hkl_interval, direction) e = generate_wt(omega_interval) ff_list = generate_form_factors(N_atoms_uc, atom_list, hkl_interval) s = [] basis = [] for a in atom_list: s.append(a.spin[2]) #z component of spin (assume aligned with z) #basis.append(a.pos) basis.append(a.pos - magCellSize) #translate back to 0,0,0 #normalize? NO! #basis.append([a.pos[0] - int(a.pos[0]), a.pos[1]-int(a.pos[1]), a.pos[2] - int(a.pos[2])]) #print "\n\nbasis vectors:\n" #mess with basis vectors and spin #basis[0] = [0.25,0,0] #basis[0] = [1.0,0,0] #tmp = s[0] #s[0] = s[1] #s[1] = tmp #for pos in basis: # print pos #print "\n\nspins:\n" #for spin in s: # print spin mesh = np.zeros((len(h_list), len(e))) #output q, w, and eigenvectors before and after normalization to compare with McQueeny's # f = open("/home/tom/Desktop/Python_Eigs.txt", 'w') # f.write("q w eigVec_before_norm T\n\n") # f2 = open("/home/tom/Desktop/Values.txt", 'w') # f2.write("Q w wvec (wvec norm) e^(-i*Q.d_i)\n\n") #create the T_ni matricies (eigenvector matrices) #This algorithm uses a differnt matrix: #evecs, mats = calc_eig_mats_numerically(Hsave, h_list,k_list,l_list) #eigvals = calc_eigs_numerically(Hsave, h_list, k_list, l_list)#This is innefficient, eigs already calculated and thrown away in calc_eig_mats_.. #w_list = gen_eigs_with_sign(Hsave, h_list, k_list, l_list, 0.001) for Qindex in range(len(h_list)): Q = (np.array([h_list, k_list, l_list]).transpose())[Qindex] # f2.write(str(Q)) #CALL SPINWAVE(q,w,evec) - get w, evec for given q M = create_matrix(atom_list, jnums, jmats, numCutOff, magCellSize, Q - np.array(tau_list)) w, evec = np.linalg.eig(M) # f2.write(" " + str(w)) # f2.write(" " + str(evec.flatten())) # evec = evecs[Qindex] # w = w_list[Qindex] # print "\nw = ", w #w1_list.append(w[0]) #w2_list.append(w[1]) #w3_list.append(w[1]) #w4_list.append(w[1]) #w5_list.append(w[1]) #w6_list.append(w[1]) #w7_list.append(w[1]) #w8_list.append(w[1]) # w_output_list.append(w) ff = ff_list[Qindex] #Get number of atoms numAtoms = numCutOff #numAtoms = np.sqrt(evec.size)#This should be the number of atoms that I need to loop through. #if int(numAtoms) != numAtoms:#I beleive t_mat should always be square, but lets check # raise Exception("t_mat not square!") #Normalize evec to get T_ni #for i in range(0, numAtoms): # normi = 0 # for j in range(0, numAtoms): # sigma_j = s[j]/np.abs(s[j]) # normi += sigma_j * np.abs(evec[j][i])**2 # for j in range(0, numAtoms): # evec[i][j] = evec[j][i]/np.sqrt(np.abs(normi)) evec2 = evec.copy() #I'm going to write this from scratch # print "evec before = ", evec T = evec sigma = [] for i in range(numAtoms): sigma.append(s[i] / np.abs(s[i])) for n in range(numAtoms): norm = 0 for i in range(numAtoms): norm += sigma[i] * (np.abs(evec2[n][i])**2) for i in range(numAtoms): # print "norm : ", norm # print "w sign: ", np.sign(w[n]) #T[n][i] = T[n][i]*np.sqrt((w[n]/np.abs(w[n]))/norm + 0j) T[n][i] = evec2[n][i] / np.sqrt(np.abs(norm)) evec = T # f2.write(" " + str(T.flatten())) #evec = evec2 # q1.append(evec[0][0]) # q2.append(evec[0][0]) #output eigs to file # f.write(str(Q)) # f.write(" w:" + str(w)) # f.write("\nmat: " + str(M))#the matrix for which the eigs were found # f.write("\nbefore_norm: " + str(evec2.flatten())) # f.write("\nafterNorm: " + str(evec.flatten()) + "\n\n") #evec = evec.transpose() #test = 0 #for i in range(numAtoms): # sigma_i = s[j]/np.abs(s[j]) # test += sigma_i * np.dot(evec[i],evec[i]) # print "sigma_i = ", sigma_i #print "\n\nsum{sigma_i * |T_ni|^2} = ", test, "\n\n" # print "evec = " , evec # print "sigma1: ", s[0]/np.abs(s[0]) # print "sigma2: ", s[1]/np.abs(s[1]) # print "sign lambda_0: ", (s[0]/np.abs(s[0]))*(evec[0][0]**2) + (s[1]/np.abs(s[1]))*(evec[0][1]**2) # print "sign lambda_1: ", (s[0]/np.abs(s[0]))*(evec[1][0]**2) + (s[1]/np.abs(s[1]))*(evec[1][1]**2) #using only positive eigenvalue #w = [w[0]] #evec = [evec[0]] #print "eigenvalues used: ", w #print "eigenvectors used: ", evec strfac = np.zeros(numAtoms) #for testing: ff = 1 for i in range(numAtoms): dum = 0 for j in range(numAtoms): dum += (s[j] / np.sqrt(np.abs( s[j]))) * ff * evec[j][i] #* np.exp(1.0j* #(-Q[0]*basis[j][0] -Q[1]*basis[j][1] -Q[2]*basis[j][2])) # print "\n\n\nwritting to f2:\n\n\n", np.exp(1.0j* # (-Q[0]*basis[j][0] -Q[1]*basis[j][1] -Q[2]*basis[j][2])) # print "j: ", j # print "basis: ", basis[j] # print "Q.di", (-Q[0]*basis[j][0] -Q[1]*basis[j][1] -Q[2]*basis[j][2]) exp = np.exp(1.0j * (-Q[0] * basis[j][0] - Q[1] * basis[j][1] - Q[2] * basis[j][2])) # f2.write(" " + str(exp)) strfac[i] = np.abs(dum)**2 # print "Q: ", Q, " strfac[",i,"]: ", strfac[i] # f2.write("\n\n") # strfac_sums.append(0.0); # strfac1.append(strfac[0]) # strfac2.append(strfac[1]) sqw = np.zeros(len(e)) for j in range(numAtoms): # strfac_sums[Qindex] +=strfac[j] for i in range(len(e)): y = LIFETIME_VALUE / 2 lorentzian = (1 / np.pi) * y / ((e[i] - w[j])**2 + y**2) #test #strfac[j] = ff*1 sqw[i] = sqw[i] + strfac[ j] * lorentzian #he has some 'bose' factor in here #more test #sqw[i] = sqw[i] + strfac[j] mesh[Qindex] = sqw #* 0.5*(1 + Q[0]**2) #along x, Q_hat is just 1? #f.close() #f = open("/home/tom/Desktop/output.txt", 'w') #for q in range(0,len(h_list)): #for w in range(0,len(e)): #f.write(str(h_list[q])) #f.write(" ") #f.write(str(e[w])) #f.write(" ") #f.write(str(mesh[q][w])) #f.write("\n") #f.close() #f = open("/home/tom/Desktop/output2.txt", 'w') #for q in range(0,len(h_list)): #f.write(str(h_list[q])) #f.write(" ") #f.write(str(np.abs(q1[q]))) #f.write(" ") #f.write(str(np.abs(q2[q]))) #f.write("\n") #f.close() #f = open("/home/tom/Desktop/output3.txt", 'w') #for q in range(0,len(h_list)): #f.write(str(h_list[q])) #f.write(" ") #f.write(str(np.real(w1_list[q]))) #f.write(" ") #f.write(str(np.real(w2_list[q]))) #f.write(" ") #f.write(str(np.real(w3_list[q]))) #f.write(" ") #f.write(str(np.real(w4_list[q]))) #f.write(" ") #f.write(str(np.real(w5_list[q]))) #f.write(" ") #f.write(str(np.real(w6_list[q]))) #f.write(" ") #f.write(str(np.real(w7_list[q]))) #f.write(" ") #f.write(str(np.real(w8_list[q]))) #f.write("\n") #f.close() #f = open("/home/tom/Desktop/strfacs.txt", 'w') #for q in range(0,len(h_list)): #f.write(str(h_list[q])) #f.write(" ") #f.write(str(k_list[q])) #f.write(" ") #f.write(str(l_list[q])) #f.write(" ") #f.write(str(strfac1[q])) #f.write(" ") #f.write(str(strfac2[q])) #f.write(" ") #f.write(str(strfac_sums[q])) #f.write("\n") #f.close() #plt.plot(w1_list) #plt.plot(w2_list) #plt.show() print "Run Time: ", time.clock() - initial_time, " seconds"
def mcQueeny_case(interactionfile, spinfile, tau_list, temperature, direction={'kx':1,'ky':0,'kz':0}, hkl_interval=[1e-3,2*np.pi,100], omega_interval=[0,5,100], eig_eps = 0.001): initial_time = time.clock() #to plot eigenvector components # q1 = [] # q2 = [] #to plot w's #w1_list = [] #w2_list = [] #w3_list = [] #w4_list = [] #w5_list = [] #w6_list = [] #w7_list = [] #w8_list = [] # w_output_list = [] #plot the structure factor to compare with lovesey (In McQueeny Paper) # strfac_sums = [] # strfac1 = [] # strfac2 = [] atom_list, jnums, jmats, N_atoms_uc, numCutOff, magCellSize = readFiles(interactionfile,spinfile, rtn_cutOffInfo = True) #Hardcoding body-center cubic if 0: atom_list = [] jnums = [0] N_atom_uc = 1 numCutOff = 7 magCellSize = np.array([1,1,1]) jmats = [np.array([[-1,0,0],[0,-1,0],[0,0,-1]])] atom_list.append(atom(pos = np.array([0.5,0.5,0.5]), spin = np.array([0,0,1]), interactions = [0,0,0,0,0,0], neighbors = [1,2,3,4,5,6])) atom_list.append(atom(pos = np.array([0.,0.,0.]), spin = np.array([0,0,-1]), interactions = [0], neighbors = [0])) atom_list.append(atom(pos = np.array([1.,0.,0.]), spin = np.array([0,0,-1]), interactions = [0], neighbors = [0])) atom_list.append(atom(pos = np.array([1.,1.,0.]), spin = np.array([0,0,-1]), interactions = [0], neighbors = [0])) atom_list.append(atom(pos = np.array([1.,0.,1.]), spin = np.array([0,0,-1]), interactions = [0], neighbors = [0])) atom_list.append(atom(pos = np.array([1.,1.,1.]), spin = np.array([0,0,-1]), interactions = [0], neighbors = [0])) atom_list.append(atom(pos = np.array([0.,1.,0.]), spin = np.array([0,0,-1]), interactions = [0], neighbors = [0])) atom_list.append(atom(pos = np.array([0.,0.,1.]), spin = np.array([0,0,-1]), interactions = [0], neighbors = [0])) atom_list.append(atom(pos = np.array([0.,1.,1.]), spin = np.array([0,0,-1]), interactions = [0], neighbors = [0])) h_list, k_list, l_list = generate_hkl(hkl_interval, direction) e = generate_wt(omega_interval) ff_list = generate_form_factors(N_atoms_uc, atom_list, hkl_interval) s = [] basis = [] for a in atom_list: s.append(a.spin[2])#z component of spin (assume aligned with z) #basis.append(a.pos) basis.append(a.pos - magCellSize) #translate back to 0,0,0 #normalize? NO! #basis.append([a.pos[0] - int(a.pos[0]), a.pos[1]-int(a.pos[1]), a.pos[2] - int(a.pos[2])]) #print "\n\nbasis vectors:\n" #mess with basis vectors and spin #basis[0] = [0.25,0,0] #basis[0] = [1.0,0,0] #tmp = s[0] #s[0] = s[1] #s[1] = tmp #for pos in basis: # print pos #print "\n\nspins:\n" #for spin in s: # print spin mesh = np.zeros((len(h_list), len(e))) #output q, w, and eigenvectors before and after normalization to compare with McQueeny's # f = open("/home/tom/Desktop/Python_Eigs.txt", 'w') # f.write("q w eigVec_before_norm T\n\n") # f2 = open("/home/tom/Desktop/Values.txt", 'w') # f2.write("Q w wvec (wvec norm) e^(-i*Q.d_i)\n\n") #create the T_ni matricies (eigenvector matrices) #This algorithm uses a differnt matrix: #evecs, mats = calc_eig_mats_numerically(Hsave, h_list,k_list,l_list) #eigvals = calc_eigs_numerically(Hsave, h_list, k_list, l_list)#This is innefficient, eigs already calculated and thrown away in calc_eig_mats_.. #w_list = gen_eigs_with_sign(Hsave, h_list, k_list, l_list, 0.001) for Qindex in range(len(h_list)): Q = (np.array([h_list,k_list,l_list]).transpose())[Qindex] # f2.write(str(Q)) #CALL SPINWAVE(q,w,evec) - get w, evec for given q M = create_matrix(atom_list, jnums, jmats, numCutOff, magCellSize, Q-np.array(tau_list)) w, evec = np.linalg.eig(M) # f2.write(" " + str(w)) # f2.write(" " + str(evec.flatten())) # evec = evecs[Qindex] # w = w_list[Qindex] # print "\nw = ", w #w1_list.append(w[0]) #w2_list.append(w[1]) #w3_list.append(w[1]) #w4_list.append(w[1]) #w5_list.append(w[1]) #w6_list.append(w[1]) #w7_list.append(w[1]) #w8_list.append(w[1]) # w_output_list.append(w) ff = ff_list[Qindex] #Get number of atoms numAtoms = numCutOff #numAtoms = np.sqrt(evec.size)#This should be the number of atoms that I need to loop through. #if int(numAtoms) != numAtoms:#I beleive t_mat should always be square, but lets check # raise Exception("t_mat not square!") #Normalize evec to get T_ni #for i in range(0, numAtoms): # normi = 0 # for j in range(0, numAtoms): # sigma_j = s[j]/np.abs(s[j]) # normi += sigma_j * np.abs(evec[j][i])**2 # for j in range(0, numAtoms): # evec[i][j] = evec[j][i]/np.sqrt(np.abs(normi)) evec2 = evec.copy() #I'm going to write this from scratch # print "evec before = ", evec T = evec sigma = [] for i in range(numAtoms): sigma.append(s[i]/np.abs(s[i])) for n in range(numAtoms): norm = 0 for i in range(numAtoms): norm += sigma[i]*(np.abs(evec2[n][i])**2) for i in range(numAtoms): # print "norm : ", norm # print "w sign: ", np.sign(w[n]) #T[n][i] = T[n][i]*np.sqrt((w[n]/np.abs(w[n]))/norm + 0j) T[n][i] = evec2[n][i]/np.sqrt(np.abs(norm)) evec = T # f2.write(" " + str(T.flatten())) #evec = evec2 # q1.append(evec[0][0]) # q2.append(evec[0][0]) #output eigs to file # f.write(str(Q)) # f.write(" w:" + str(w)) # f.write("\nmat: " + str(M))#the matrix for which the eigs were found # f.write("\nbefore_norm: " + str(evec2.flatten())) # f.write("\nafterNorm: " + str(evec.flatten()) + "\n\n") #evec = evec.transpose() #test = 0 #for i in range(numAtoms): # sigma_i = s[j]/np.abs(s[j]) # test += sigma_i * np.dot(evec[i],evec[i]) # print "sigma_i = ", sigma_i #print "\n\nsum{sigma_i * |T_ni|^2} = ", test, "\n\n" # print "evec = " , evec # print "sigma1: ", s[0]/np.abs(s[0]) # print "sigma2: ", s[1]/np.abs(s[1]) # print "sign lambda_0: ", (s[0]/np.abs(s[0]))*(evec[0][0]**2) + (s[1]/np.abs(s[1]))*(evec[0][1]**2) # print "sign lambda_1: ", (s[0]/np.abs(s[0]))*(evec[1][0]**2) + (s[1]/np.abs(s[1]))*(evec[1][1]**2) #using only positive eigenvalue #w = [w[0]] #evec = [evec[0]] #print "eigenvalues used: ", w #print "eigenvectors used: ", evec strfac = np.zeros(numAtoms) #for testing: ff = 1 for i in range(numAtoms): dum = 0 for j in range(numAtoms): dum += (s[j]/np.sqrt(np.abs(s[j]))) * ff * evec[j][i] #* np.exp(1.0j* #(-Q[0]*basis[j][0] -Q[1]*basis[j][1] -Q[2]*basis[j][2])) # print "\n\n\nwritting to f2:\n\n\n", np.exp(1.0j* # (-Q[0]*basis[j][0] -Q[1]*basis[j][1] -Q[2]*basis[j][2])) # print "j: ", j # print "basis: ", basis[j] # print "Q.di", (-Q[0]*basis[j][0] -Q[1]*basis[j][1] -Q[2]*basis[j][2]) exp = np.exp(1.0j*(-Q[0]*basis[j][0] -Q[1]*basis[j][1] -Q[2]*basis[j][2])) # f2.write(" " + str(exp)) strfac[i] = np.abs(dum)**2 # print "Q: ", Q, " strfac[",i,"]: ", strfac[i] # f2.write("\n\n") # strfac_sums.append(0.0); # strfac1.append(strfac[0]) # strfac2.append(strfac[1]) sqw = np.zeros(len(e)) for j in range(numAtoms): # strfac_sums[Qindex] +=strfac[j] for i in range(len(e)): y = LIFETIME_VALUE/2 lorentzian = (1/np.pi)*y/((e[i]- w[j])**2+y**2) #test #strfac[j] = ff*1 sqw[i] = sqw[i] + strfac[j] * lorentzian #he has some 'bose' factor in here #more test #sqw[i] = sqw[i] + strfac[j] mesh[Qindex] = sqw #* 0.5*(1 + Q[0]**2) #along x, Q_hat is just 1? #f.close() #f = open("/home/tom/Desktop/output.txt", 'w') #for q in range(0,len(h_list)): #for w in range(0,len(e)): #f.write(str(h_list[q])) #f.write(" ") #f.write(str(e[w])) #f.write(" ") #f.write(str(mesh[q][w])) #f.write("\n") #f.close() #f = open("/home/tom/Desktop/output2.txt", 'w') #for q in range(0,len(h_list)): #f.write(str(h_list[q])) #f.write(" ") #f.write(str(np.abs(q1[q]))) #f.write(" ") #f.write(str(np.abs(q2[q]))) #f.write("\n") #f.close() #f = open("/home/tom/Desktop/output3.txt", 'w') #for q in range(0,len(h_list)): #f.write(str(h_list[q])) #f.write(" ") #f.write(str(np.real(w1_list[q]))) #f.write(" ") #f.write(str(np.real(w2_list[q]))) #f.write(" ") #f.write(str(np.real(w3_list[q]))) #f.write(" ") #f.write(str(np.real(w4_list[q]))) #f.write(" ") #f.write(str(np.real(w5_list[q]))) #f.write(" ") #f.write(str(np.real(w6_list[q]))) #f.write(" ") #f.write(str(np.real(w7_list[q]))) #f.write(" ") #f.write(str(np.real(w8_list[q]))) #f.write("\n") #f.close() #f = open("/home/tom/Desktop/strfacs.txt", 'w') #for q in range(0,len(h_list)): #f.write(str(h_list[q])) #f.write(" ") #f.write(str(k_list[q])) #f.write(" ") #f.write(str(l_list[q])) #f.write(" ") #f.write(str(strfac1[q])) #f.write(" ") #f.write(str(strfac2[q])) #f.write(" ") #f.write(str(strfac_sums[q])) #f.write("\n") #f.close() #plt.plot(w1_list) #plt.plot(w2_list) #plt.show() print "Run Time: ", time.clock()-initial_time, " seconds"
def generate_cross_section(interactionfile, spinfile, lattice, arg, tau_list, h_list, k_list, l_list, w_list): """ Calculates the cross_section given the following parameters: interactionfile, spinfile - files to get atom data lattice - Lattice object from tripleaxisproject arg - reduced list of operator combinations tau_list - list of tau position w_list - list of w's probed """ # Read files, get atom_list and such atom_list, jnums, jmats,N_atoms_uc=readFiles(interactionfile,spinfile) # Get Hsave to calculate its eigenvalues N_atoms = len(atom_list) Hsave,poly,heigs = calculate_dispersion(atom_list,N_atoms_uc,N_atoms,jmats,showEigs=True) atom_list=atom_list[:N_atoms_uc] N_atoms = len(atom_list) N = N_atoms print "Calculated: Dispersion Relation" # Generate kappas from (h,k,l) kaprange=lattice.modvec(h_list,k_list,l_list, 'latticestar') nkpts=len(kaprange) kapvect=np.empty((nkpts,3),'Float64') kapvect[:,0]=h_list kapvect[:,1]=k_list kapvect[:,2]=l_list # Grabs the unit vectors from the back of the lists. kapunit = kapvect.copy() kapunit[:,0]=kapvect[:,0]/kaprange kapunit[:,1]=kapvect[:,1]/kaprange kapunit[:,2]=kapvect[:,2]/kaprange unit_vect = [] for i in range(len(arg)): unit_vect.append(arg[i].pop()) #print unit_vect unit_vect = sum(unit_vect) # Generate qs from kappas and taus qlist=[] ones_list=np.ones((1,nkpts),'Float64') for tau in tau_list: taui=np.ones((nkpts,3),'Float64') taui[:,0]=ones_list*tau[0] taui[:,1]=ones_list*tau[1] taui[:,2]=ones_list*tau[2] kappa_minus_tau=kapvect-taui tau_minus_kappa=taui - kapvect qlist.append(np.vstack([kappa_minus_tau,tau_minus_kappa])) # Eigenvalues and omegas wtlist=w_list eig_list=[] eigs = Hsave.eigenvals().keys() for q in qlist: eig_list.append(eigs) eig_list = np.array(eig_list) print "Calculated: Eigenvalues" # Form Factor ff_list = [] for i in range(N_atoms_uc): el = elements[atom_list[i].atomicNum] val = atom_list[i].valence if val != None: Mq = el.magnetic_ff[val].M_Q(kaprange) else: Mq = el.magnetic_ff[0].M_Q(kaprange) ff_list = Mq #ff_list.append(Mq) print "Calculated: Form Factors" # Generate most general form of csection csection=0 for i in range(len(arg)): for j in range(len(arg[i])): csection = (csection + arg[i][j]*unit_vect) for i in range(N): ni = sp.Symbol('n%i'%(i,), real = True) np1i = sp.Symbol('np1%i'%(i,), Real = True) csection.subs(ni+1,np1i) csection = csection.expand() csection = csection.subs(KAPXHAT_SYM*KAPYHAT_SYM,0) csection = csection.subs(KAPXHAT_SYM*KAPZHAT_SYM,0) csection = csection.subs(KAPYHAT_SYM*KAPZHAT_SYM,0) csection = csection.subs(KAPZHAT_SYM*KAPYHAT_SYM,0) csection = csection.subs(KAPZHAT_SYM*KAPXHAT_SYM,0) csection = csection.subs(KAPYHAT_SYM*KAPXHAT_SYM,0) csection = (csection * exp(-I * W_SYM * T_SYM) * exp(I * KAP_SYM * L_SYM)).expand(deep=False) csection = sp.powsimp(csection, deep=True) print 'beginning' # print csection csection = sp.powsimp(csection) csection = sub_in(csection,exp(I*T_SYM*A_WILD + I*T_SYM*B_WILD + I*C_WILD + I*D_WILD + I*K_WILD),sp.DiracDelta(A_WILD*T_SYM + B_WILD*T_SYM + C_WILD + D_WILD + K_WILD)) print 'intermediate' # print csection # csection = sub_in(csection,sp.DiracDelta(A*t + B*t + C*L + D*L ),(1./hbar)*sp.DiracDelta(A + B)*sp.simplify(sp.DiracDelta(C + D - tau))) #This is correct csection = sub_in(csection,sp.DiracDelta(A_WILD*T_SYM + B_WILD*T_SYM + C_WILD*L_SYM + D_WILD*L_SYM ),sp.Pow(pi,-1)*(LIFETIME_VALUE*0.5)*sp.Pow((A_WILD+B_WILD)**2+(LIFETIME_VALUE*0.5)**2,-1)*sp.simplify(sp.DiracDelta(C_WILD + D_WILD - TAU_SYM))) print 'ending' # print csection # Do some associative clean up to make it easier for later substitutions csection = sub_in(csection,sp.DiracDelta(-A_WILD - B_WILD),sp.DiracDelta(A_WILD + B_WILD)) csection = sub_in(csection,(-A_WILD - B_WILD)**2,(A_WILD + B_WILD)**2) csection = csection.subs(sp.DiracDelta(Q_SYM + TAU_SYM - KAP_SYM),sp.DiracDelta(KAP_SYM - Q_SYM - TAU_SYM)) csection = csection.subs(sp.DiracDelta(TAU_SYM - KAP_SYM - Q_SYM),sp.DiracDelta(KAP_SYM + Q_SYM - TAU_SYM)) csection = csection.subs(sp.DiracDelta(KAP_SYM - Q_SYM - TAU_SYM),DD_KTMQ_SYM) csection = csection.subs(sp.DiracDelta(KAP_SYM + Q_SYM - TAU_SYM),DD_KTPQ_SYM) print "Applied: Delta Function Conversion" print csection print "Generated: Analytic Cross-Section Expression" return (N_atoms_uc, csection, kaprange, tau_list, eig_list, kapvect, wtlist, ff_list)
def generate_cross_section(interactionfile, spinfile, lattice, arg, tau_list, h_list, k_list, l_list, w_list): """ Calculates the cross_section given the following parameters: interactionfile, spinfile - files to get atom data lattice - Lattice object from tripleaxisproject arg - reduced list of operator combinations tau_list - list of tau position w_list - list of w's probed """ # Read files, get atom_list and such atom_list, jnums, jmats,N_atoms_uc=readFiles(interactionfile,spinfile) # Get Hsave to calculate its eigenvalues N_atoms = len(atom_list) Hsave,poly,heigs = calculate_dispersion(atom_list,N_atoms_uc,N_atoms,jmats,showEigs=True) atom_list=atom_list[:N_atoms_uc] N_atoms = len(atom_list) N = N_atoms print "Calculated: Dispersion Relation" kaprange=lattice.modvec(h_list,k_list,l_list, 'latticestar') nkpts=len(kaprange) kapvect=np.empty((nkpts,3),'Float64') kapvect[:,0]=h_list kapvect[:,1]=k_list kapvect[:,2]=l_list kapunit = kapvect.copy() kapunit[:,0]=kapvect[:,0]/kaprange kapunit[:,1]=kapvect[:,1]/kaprange kapunit[:,2]=kapvect[:,2]/kaprange plusq=[] minusq=[] qlist=[] ones_list=np.ones((1,nkpts),'Float64') wtlist=w_list qtlist=[] for tau in tau_list: taui=np.ones((nkpts,3),'Float64') taui[:,0]=ones_list*tau[0] taui[:,1]=ones_list*tau[1] taui[:,2]=ones_list*tau[2] kappa_minus_tau=kapvect-taui tau_minus_kappa=taui - kapvect qlist.append(np.vstack([kappa_minus_tau,tau_minus_kappa])) eig_list=[] eigs = Hsave.eigenvals().keys() for q in qlist: eig_list.append(eigs) eig_list = np.array(eig_list) print "Calculated: Eigenvalues" # Other Constants kap = sp.Symbol('kappa', real = True) t = sp.Symbol('t', real = True) w = sp.Symbol('w', real = True) W = sp.Symbol('W', real = True) tau = sp.Symbol('tau', real = True) Q = sp.Symbol('q', real = True) L = sp.Symbol('L', real = True) lifetime=0.5 # Form Factor ff_list = [] for i in range(N_atoms_uc): el = elements[atom_list[i].atomicNum] val = atom_list[i].valence if val != None: Mq = el.magnetic_ff[val].M_Q(kaprange) else: Mq = el.magnetic_ff[0].M_Q(kaprange) ff_list = Mq #ff_list.append(Mq) print "Calculated: Form Factors" # Wilds for sub_in method A = sp.Wild('A',exclude = [0,t]) B = sp.Wild('B',exclude = [0,t]) C = sp.Wild('C') D = sp.Wild('D') # Grabs the unit vectors from the back of the lists. unit_vect = [] kapxhat = sp.Symbol('kapxhat',real=True) kapyhat = sp.Symbol('kapyhat',real=True) kapzhat = sp.Symbol('kapzhat',real=True) for i in range(len(arg)): unit_vect.append(arg[i].pop()) unit_vect = sum(unit_vect) csection=0 for i in range(len(arg)): for j in range(len(arg[i])): csection = (csection + arg[i][j]*unit_vect) for i in range(N): ni = sp.Symbol('n%i'%(i,), real = True) np1i = sp.Symbol('np1%i'%(i,), Real = True) csection.subs(ni+1,np1i) csection = csection.expand() csection = csection.subs(kapxhat*kapyhat,0) csection = csection.subs(kapxhat*kapzhat,0) csection = csection.subs(kapyhat*kapzhat,0) csection = csection.subs(kapzhat*kapyhat,0) csection = csection.subs(kapzhat*kapxhat,0) csection = csection.subs(kapyhat*kapxhat,0) csection = (csection * exp(-I*w*t) * exp(I*kap*L)).expand(deep=False) csection = sp.powsimp(csection, deep=True) print 'beginning delta conversion' print csection csection = sp.powsimp(csection) csection = sub_in(csection,exp(I*t*A + I*t*B + I*C + I*D + I*K),sp.DiracDelta(A*t + B*t + C + D + K)) print 'intermediate' print csection # csection = sub_in(csection,sp.DiracDelta(A*t + B*t + C*L + D*L ),(1./hbar)*sp.DiracDelta(A + B)*sp.simplify(sp.DiracDelta(C + D - tau))) #This is correct csection = sub_in(csection,sp.DiracDelta(A*t + B*t + C*L + D*L ),sp.Pow(pi,-1)*(lifetime*0.5)*sp.Pow((A+B)**2+(lifetime*0.5)**2,-1)*sp.simplify(sp.DiracDelta(C + D - tau))) print 'ending delta conversion' print csection csection = sub_in(csection,sp.DiracDelta(-A - B),sp.DiracDelta(A + B)) csection = sub_in(csection,(-A - B)**2,(A + B)**2) csection = csection.subs(sp.DiracDelta(Q+tau-kap),sp.DiracDelta(kap-Q-tau)) csection = csection.subs(sp.DiracDelta(tau-kap-Q),sp.DiracDelta(kap+Q-tau)) print "Applied: Delta Function Conversion" print "end part 1" #print csection return (N_atoms_uc, csection, kaprange, tau_list, eig_list, kapvect, wtlist, ff_list)
if 0: a = [1, 2, 3, 4, 5, 6, 7] b = [1, 2, 5] comms = [a[i] in b for i in range(len(a))] print comms x = sp.Symbol('x') y = x**2 print type(y) print y.is_commutative print y.atoms() if 0: interfile = 'c:/test_montecarlo.txt' spinfile = 'c:/test_Spins.txt' atom_list, jnums, jmats, N_atoms_uc = rf.readFiles(interfile, spinfile) N_atoms = len(atom_list) jij_values = [] jij_columns = [] jij_rowIndex = [] # Scan through atom_list num_inters = 0 for i in range(N_atoms): ints_list = atom_list[i].interactions nbrs_list = atom_list[i].neighbors print 'ints', ints_list print 'nbrs', nbrs_list nbrs_ints = [(nbrs_list[x], ints_list[x]) for x in range(len(nbrs_list))] nbrs_ints.sort()
def run_cross_section(interactionfile, spinfile): start = clock() # Generate Inputs atom_list, jnums, jmats,N_atoms_uc=readFiles(interactionfile,spinfile) atom1 = atom(pos = [0.00,0,0], neighbors = [1], interactions = [0], int_cell = [0], atomicNum = 26, valence = 3) atom2 = atom(pos = [0.25,0,0], neighbors = [0,2], interactions = [0], int_cell = [0], atomicNum = 26, valence = 3) atom3 = atom(pos = [0.50,0,0], neighbors = [1,3], interactions = [0], int_cell = [0], atomicNum = 26, valence = 3) atom4 = atom(pos = [0.75,0,0], neighbors = [2], interactions = [0], int_cell = [0], atomicNum = 26, valence = 3) # atom_list,N_atoms_uc = ([atom1, atom2, atom3, atom4],1) atom_list=atom_list[:N_atoms_uc] N_atoms = len(atom_list) print N_atoms if 1: kx = sp.Symbol('kx', real = True) ky = sp.Symbol('ky', real = True) kz = sp.Symbol('kz', real = True) k = spm.Matrix([kx,ky,kz]) (b,bd) = generate_b_bd_operators(atom_list) # list_print(b) (a,ad) = generate_a_ad_operators(atom_list, k, b, bd) # list_print(a) (Sp,Sm) = generate_Sp_Sm_operators(atom_list, a, ad) # list_print(Sp) (Sa,Sb,Sn) = generate_Sa_Sb_Sn_operators(atom_list, Sp, Sm) # list_print(Sa) (Sx,Sy,Sz) = generate_Sx_Sy_Sz_operators(atom_list, Sa, Sb, Sn) # list_print(Sx) print '' #Ham = generate_Hamiltonian(N_atoms, atom_list, b, bd) ops = generate_possible_combinations(atom_list, [Sx,Sy,Sz]) # list_print(ops) ops = holstein(atom_list, ops) # list_print(ops) ops = apply_commutation(atom_list, ops) # list_print(ops) ops = replace_bdb(atom_list, ops) # list_print(ops) ops = reduce_options(atom_list, ops) list_print(ops) # Old Method #cross_sect = generate_cross_section(atom_list, ops, 1, real, recip) #print '\n', cross_sect if 1: aa = bb = cc = np.array([2.0*np.pi], 'Float64') alpha = beta = gamma = np.array([np.pi/2.0], 'Float64') vect1 = np.array([[1,0,0]]) vect2 = np.array([[0,0,1]]) lattice = Lattice(aa, bb, cc, alpha, beta, gamma, Orientation(vect1, vect2)) data={} data['kx']=1. data['ky']=0. data['kz']=0. direction=data temperature = 1.0 kmin = 0 kmax = 2*sp.pi steps = 25 tau_list = [] for i in range(1): tau_list.append(np.array([0,0,0], 'Float64')) h_list = np.linspace(0.1,12.0,200) k_list = np.zeros(h_list.shape) l_list = np.zeros(h_list.shape) w_list = np.linspace(0.1,10.0,200) efixed = 14.7 #meV eief = True N_atoms_uc,csection,kaprange,qlist,tau_list,eig_list,kapvect,wtlist = generate_cross_section(interactionfile, spinfile, lattice, ops, tau_list, h_list, k_list, l_list, w_list, temperature, steps, eief, efixed) print csection return N_atoms_uc,csection,kaprange,qlist,tau_list,eig_list,kapvect,wtlist end = clock() print "\nFinished %i atoms in %.2f seconds" %(N_atoms,end-start)
def csection(interactionfile, spinfile, tau_list, temp = 0.0001, HWHM = 1/np.pi, direction={'kx':1,'ky':0,'kz':0}, hkl_interval=[1e-3,2*np.pi,100], omega_interval=[0,5,100], kb = 0.086173423): """ kb is the boltzman constant in whatever units the user is using. The default is 0.086173423 meV/K. HWHM is the half width at half maximum of the lorentzian broadening function (the resolution of the energy).""" initial_time = time.clock() atom_list, jnums, jmats, N_atoms_uc, numCutOff, magCellSize = readFiles(interactionfile,spinfile, rtn_cutOffInfo = True) #Atoms in the first interaction cell come first in the list (atom_list),so #I can iterate through the first numCutOff atoms in the list top iterate #only through the atoms in the first interaction cell - I beleive 1/4/12 #Right now (1/12/12) a major issue is that this method requires the size #of the magnetic cell and the cutOffCell size is not necesssarilly the #same as the magenetic cell size. In fact, even in the very simple #ferromagnetic chain it is not. - Same issue with numCutOff - should be #numMagCell #Simple Ferro Case #magCellSize = np.array([1,1,1]) #numCutOff =1 #testing #numCutOff = 2 #magCellSize = np.array([1,1,1]) #generate all the parameters I will need h_list, k_list, l_list = generate_hkl(hkl_interval, direction) #test #h_list = 2*np.pi*h_list #k_list = 2*np.pi*k_list #l_list = 2*np.pi*l_list e_vals = generate_wt(omega_interval) mesh = np.zeros((len(h_list),len(e_vals)), dtype = complex) #mu_hat is a unit vector pointing in the direction of positive spin, which #I defined to be the direction of the spin of the atom whcih comes first in #the list. I haven't though about whether the sign will make a difference #in the final result, but it does not really matter as the choice of #positive direction will always be arbitrary. spin = np.array(atom_list[0].spin) mu_hat = spin/np.sqrt(np.dot(spin,spin)) ff_list = generate_form_factors(N_atoms_uc, atom_list, hkl_interval) s = [] sigmas = [] basis = [] for a in atom_list: s.append(np.abs(np.dot(a.spin, mu_hat))) sigmas.append(np.dot(a.spin,mu_hat)/s[-1]) #translate back to 0,0,0, but leave in crystallographic cell dimensions basis.append(a.pos - magCellSize) #I'm leaving it in crystallographic cell dimensions rather than magnetic #cell dimensions so that the periodicity of the dispersion relation #matches what we already calculate with the William's code, rather than #McQueeny's w_list = [] Q_points = (np.array([h_list,k_list,l_list]).transpose()) S_q = [] #For testing - S at the w points where S is maximized #calculate the cross section for each Q point (h,k,l) for Qindex in range(len(h_list)): Q = np.array(Q_points[Qindex]) #create the matrix and find the eigenvalues and eigenvectors M = create_matrix(atom_list, jnums, jmats, numCutOff, magCellSize, Q-np.array(tau_list), mu_hat) w, evec = np.linalg.eig(M) w_list.append(w)#testing ff = ff_list[Qindex] #Get number of atoms numAtoms = numCutOff T = np.empty((numAtoms, numAtoms), dtype = complex)#normalized eigenvectors #Normalize evec to get T_ni for n in range(0, numAtoms): sgn_ln = w[n]/abs(w[n]) tmp = 0.0 for i in range(0, numAtoms): tmp += sigmas[i] * abs(evec[i][n])**2 C = sgn_ln/tmp for i in range(0, numAtoms): T[i][n] = evec[i][n]*cmath.sqrt(C) #The indices of T actually go T[i][n], where n corresponds to the #eigenvalue, w[n], and i corresponds to the ith atom on the cell #1/12/12 The Matrix and T are tested for the simple antiferro case and #found to be correct #Now calculate the S(Q,w) / structure factor #mu_hat is a unit vector pointing in the direction of the spins #All the pins are aligned up to their sign, which does not matter here. #This method will work whether the spins are aligned along the z axis #or not. pol_factor = 0.5*(1.0 + (np.dot(mu_hat,Q)**2)/np.dot(Q,Q)) gamma = ff #I need to make sure this is the same as his formfactor gamma = 1.0#testing #strfac = 0.0 #For this one Q point, we get a whole S vs. e array tmp_e_dimension_array = np.zeros((len(e_vals)), dtype = complex) S_q.append(0.0) for n in range(numAtoms): strfac = 0.0 for i in range(numAtoms): d_i = np.array(basis[i], dtype = np.float64)/np.array(magCellSize, dtype = np.float64) strfac += gamma*sigmas[i]*np.sqrt(s[i])*T[i][n]*np.exp(-1j*np.dot(Q,d_i)) strfac = np.abs(strfac)**2 #test: S_q[-1] += strfac #The 'Bose Occupation Factor,' as McQueeny calls it, which, I #believe is the Bose-Einstein distribution for identical bosons n_qn = 1.0/(np.exp(w[n]/(temp*kb)) - 1.0) #replace the delta function with a lorentzian for e_index in range(len(e_vals)): #delta(w - w_n(q)) lorentzian1 = (1.0/np.pi)*HWHM/((e_vals[e_index] - w[n])**2 + HWHM**2) tmp_e_dimension_array += strfac*(n_qn+1.0)*lorentzian1 #McQueeny left the other delta function out of his code, so for #now, I did too. #A test shows that numpy actually copies the values (not references) mesh[Qindex] = pol_factor * tmp_e_dimension_array #Right now, mesh is only S(Q,w), not the full cross section, which is: #r_0^2 * k'/k * S(Q,w) r_0 = 1.0 kp = 1.0 k = 1.0 #print "Run Time: ", time.clock()-initial_time, " seconds" #testing w_list = np.array(w_list) for i in range(len(w_list)): print Q_points[i], "\t", S_q[i] plt.plot(np.linspace(hkl_interval[0],hkl_interval[1], hkl_interval[2])[2:-2], S_q[2:-2]) plt.show() return (r_0**2) * (kp/k) * mesh
def eval_cross_section(interactionfile, spinfile, lattice, arg, tau_list, h_list, k_list, l_list, w_vect_list, direction, temperature, kmin, kmax, steps, eief, efixed = 14.7): """ Calculates the cross_section given the following parameters: interactionfile, spinfile - files to get atom data lattice - Lattice object from tripleaxisproject arg - reduced list of operator combinations tau_list - list of tau position w_list - list of w's probed direction - direction of scan temp - temperature kmin - minimum value of k to scan kmax - maximum value of k to scan steps - number of steps between kmin, kmax eief - True if the energy scheme is Ei - Ef, False if it is Ef - Ei efixed - value of the fixed energy, either Ei or Ef """ # Read files, get atom_list and such atom_list, jnums, jmats,N_atoms_uc=readFiles(interactionfile,spinfile) N_atoms = len(atom_list) N = N_atoms # TEMPORARY TO OVERRIDE ATOM_LIST ABOVE # atom1 = atom(pos = [0.00,0,0], neighbors = [1], interactions = [0], int_cell = [0], # atomicNum = 26, valence = 3, spinRmatrix=spm.Matrix([[1, 0, 0],[0, 1, 0],[0, 0, 1]])) # atom2 = atom(pos = [0.25,0,0], neighbors = [0,2], interactions = [0], int_cell = [0], # atomicNum = 26, valence = 3, spinRmatrix=spm.Matrix([[1, 0, 0],[0, 1, 0],[0, 0, 1]])) # atom3 = atom(pos = [0.50,0,0], neighbors = [1,3], interactions = [0], int_cell = [0], # atomicNum = 26, valence = 3, spinRmatrix=spm.Matrix([[1, 0, 0],[0, 1, 0],[0, 0, 1]])) # atom4 = atom(pos = [0.75,0,0], neighbors = [2], interactions = [0], int_cell = [0], # atomicNum = 26, valence = 3, spinRmatrix=spm.Matrix([[1, 0, 0],[0, 1, 0],[0, 0, 1]])) # atom_list,N_atoms_uc = ([atom1, atom2, atom3, atom4],1) N_atoms = len(atom_list) # Get Hsave to calculate its eigenvalues (Hsave, charpoly, eigs) = calculate_dispersion(atom_list,N_atoms_uc,N_atoms,jmats,showEigs=True) print "Calculated: Dispersion Relation" # Generate kappa's from (h,k,l) kaprange = [] kapvect = [] if len(h_list) == len(k_list) == len(l_list): for i in range(len(h_list)): kappa = lattice.modvec(h_list[i],k_list[i],l_list[i], 'latticestar') kaprange.append(kappa[0]) kapvect.append(np.array([h_list[i],k_list[i],l_list[i]])) # kapvect.append(np.array([h_list[i]/kappa,k_list[i]/kappa,l_list[i]/kappa])) else: raise Exception('h,k,l not same lengths') # Generate q's from kappa and tau pqrange = [] mqrange = [] for tau in tau_list: ptemp = [] mtemp = [] for kap in kapvect: #tau = lattice.modvec(tau[0],tau[1],tau[2], 'latticestar') ptemp.append(kap - tau) mtemp.append(tau - kap) pqrange.append(ptemp) mqrange.append(mtemp) # Calculate w_q's using q qrange = [] # krange = [] wrange = [] if 1: # Change this later for set in pqrange: temp = [] temp1 = [] for q in set: eigs = calc_eigs(Hsave,q[0]*direction['kx'], q[1]*direction['ky'], q[2]*direction['kz']) # Take only one set of eigs. Should probably have a flag here. temp.append(eigs[0]) # krange.append(np.array([q*direction['kx'], q*direction['ky'], q*direction['kz']])) temp1.append(q) wrange.append(temp) qrange.append(temp1) print "Calculated: Eigenvalues" wrange=np.array(np.real(wrange)) qrange=np.array(np.real(qrange)) kaprange=np.array(np.real(kaprange)) print qrange.shape print wrange.shape print kaprange.shape # Calculate w (not _q) as well as kp/k w_calc = [] kpk = [] if eief == True: for tau in tau_list: temp = [] temp1 = [] for om in w_vect_list: temp.append(om - efixed) temp1.append(np.sqrt(om/efixed)) w_calc.append(temp) kpk.append(temp1) else: for tau in tau_list: temp = [] temp1 = [] for om in w_vect_list: temp.append(-(om - efixed)) temp1.append(np.sqrt(efixed/om)) w_calc.append(temp) kpk.append(temp1) w_calc = np.array(np.real(w_calc)) # Grab Form Factors ff_list = [] s = sp.Symbol('s') for i in range(N_atoms): el = elements[atom_list[i].atomicNum] val = atom_list[i].valence if val != None: Mq = el.magnetic_ff[val].M_Q(kaprange) else: Mq = el.magnetic_ff[0].M_Q(kaprange) ff_list.append(Mq) print "Calculated: Form Factors" # Other Constants gamr0 = 2*0.2695*10**(-12) #sp.Symbol('gamma', commutative = True) hbar = 1.0 # 1.05457148*10**(-34) #sp.Symbol('hbar', commutative = True) g = 2.#sp.Symbol('g', commutative = True) # Kappa vector kap = sp.Symbol('kappa', real = True)#spm.Matrix([sp.Symbol('kapx',real = True),sp.Symbol('kapy',real = True),sp.Symbol('kapz',real = True)]) t = sp.Symbol('t', real = True) w = sp.Symbol('w', real = True) W = sp.Symbol('W', real = True) tau = sp.Symbol('tau', real = True) q = sp.Symbol('q', real = True) L = sp.Symbol('L', real = True) boltz = 1.#1.3806503*10**(-23) # Wilds for sub_in method A = sp.Wild('A',exclude = [0,t]) B = sp.Wild('B',exclude = [0,t]) C = sp.Wild('C') D = sp.Wild('D') K = sp.Wild('K') # First the exponentials are turned into delta functions: for i in range(len(arg)): for j in range(N): print '1', arg[i][j] arg[i][j] = sp.powsimp(arg[i][j])#sp.powsimp(arg[i][j], deep = True, combine = 'all') arg[i][j] = (arg[i][j] * exp(-I*w*t) * exp(I*kap*L)).expand()# * exp(I*inner_prod(spm.Matrix(atom_list[j].pos).T,kap)) arg[i][j] = sp.powsimp(arg[i][j])#sp.powsimp(arg[i][j], deep = True, combine = 'all') # print '2', arg[i][j] arg[i][j] = sub_in(arg[i][j],exp(I*t*A + I*t*B + I*C + I*D + I*K),sp.DiracDelta(A*t + B*t + C + D + K))#*sp.DiracDelta(C)) # print '3', arg[i][j] arg[i][j] = sub_in(arg[i][j],sp.DiracDelta(A*t + B*t + C*L + D*L + K*L),sp.DiracDelta(A*hbar + B*hbar)*sp.simplify(sp.DiracDelta(C + D + K + tau))) # print '4', arg[i][j] arg[i][j] = sub_in(arg[i][j],sp.DiracDelta(-A - B)*sp.DiracDelta(C),sp.DiracDelta(A + B)*sp.DiracDelta(C)) print '5', arg[i][j] print "Applied: Delta Function Conversion" # Grabs the unit vectors from the back of the lists. unit_vect = [] kapxhat = sp.Symbol('kapxhat',commutative = False) kapyhat = sp.Symbol('kapyhat',commutative = False) kapzhat = sp.Symbol('kapzhat',commutative = False) for i in range(len(arg)): unit_vect.append(arg[i].pop()) # Subs the actual values for kx,ky,kz, omega_q and n_q into the operator combos # The result is basically a nested list: # # csdata = [ op combos ] # op combos = [ one combo per atom ] # 1 per atom = [ evaluated exp ] # csdata = [] for i in range(len(arg)): temp1 = [] for j in range(len(arg[i])): temp2 = [] for k in range(len(tau_list)): temp3 = [] print i,j,k for g in range(len(qrange[k])): pvalue = tau_list[k] + kapvect[g] + qrange[k][g] mvalue = tau_list[k] + kapvect[g] - qrange[k][g] if pvalue[0] == 0 and pvalue[1] == 0 and pvalue[2] == 0: arg[i][j] = arg[i][j].subs(sp.DiracDelta(kap+tau+q),sp.DiracDelta(0)) else: arg[i][j] = arg[i][j].subs(sp.DiracDelta(kap+tau+q),0) if mvalue[0] == 0 and mvalue[1] == 0 and mvalue[2] == 0: arg[i][j] = arg[i][j].subs(sp.DiracDelta(kap+tau-q),sp.DiracDelta(0)) else: arg[i][j] = arg[i][j].subs(sp.DiracDelta(kap+tau-q),0) wq = sp.Symbol('wq', real = True) nq = sp.Symbol('n%i'%(k,), commutative = False) arg[i][j] = arg[i][j].subs(wq,wrange[k][g]) arg[i][j] = arg[i][j].subs(w,w_calc[k][g]) n = sp.Pow( sp.exp(hbar*wrange[k][g]/boltz*temperature) - 1 ,-1) arg[i][j] = arg[i][j].subs(nq,n) temp3.append(arg[i][j]) temp2.append(temp3) temp1.append(temp2) csdata.append(temp1) ## print arg[i][j] # for g in range(len(kaprange)): # arg[i][j] = arg[i][j].subs(kap, kaprange[g]) # for g in range(len(krange)): ## print 'calculating' # temp3 = [] # wg = sp.Symbol('w%i'%(g,), real = True) # ng = sp.Symbol('n%i'%(g,), commutative = False) ## kx = sp.Symbol('kx', real = True, commutative = True) ## ky = sp.Symbol('ky', real = True, commutative = True) ## kz = sp.Symbol('kz', real = True, commutative = True) ## arg[i][j] = arg[i][j].subs(kx,krange[g][0]) ## arg[i][j] = arg[i][j].subs(ky,krange[g][1]) ## arg[i][j] = arg[i][j].subs(kz,krange[g][2]) # arg[i][j] = arg[i][j].subs(wg,wrange[g]) # arg[i][j] = arg[i][j].subs(w,w_calc[g]) # nq = sp.Pow( sp.exp(hbar*wrange[g]/boltz*temp) - 1 ,-1) # arg[i][j] = arg[i][j].subs(ng,nq) ## arg[i][j] = arg[i][j].subs(tau,tau_list[0]) # # temp3.append(arg[i][j]) ## print arg[i][j] # temp2.append(temp3) ## print arg[i][j] # csdata.append(temp2) print csdata # Front constants and stuff for the cross-section front_constant = 1.0 # (gamr0)**2/(2*pi*hbar) front_func = (1./2.)*g#*F(k) vanderwaals = 1. #exp(-2*W) csrange = [] if 1: temp1 = [] temp2 = [] for q in range(len(qrange)): print 'calculating' for ii in range(len(csdata)): for jj in range(len(csdata[ii])): temp1.append(csdata[ii][jj]) # Put on gamr0, 2pi hbar, form factor, kp/k, vanderwaals first dif = front_func**2 * front_constant# * kpk[q][0] * vanderwaals * ff_list[0][q] # for vect in unit_vect: # vect.subs(kapxhat,kapvect[q][0][0]) # vect.subs(kapyhat,kapvect[q][1][0]) # vect.subs(kapzhat,kapvect[q][2][0]) print 'diff',dif print 'temp1',temp1 print sum(temp1) dif = (dif * sum(temp1))# * sum(unit_vect))#.expand() csrange.append(dif) print "Calculated: Cross-section" csrange=np.real(csrange) csrange=np.array(csrange) xi=qrange yi=wrange zi=csrange Z=np.zeros((xi.shape[0],yi.shape[0])) Z[range(len(xi)),range(len(yi))]=zi pylab.contourf(xi,yi,Z) pylab.colorbar() pylab.show()