def run_dispersion(lattice, num_uc=1, eigs=False, eigsP=False): num = len(lattice) inters = [item for atom in lattice for item in atom.interactions] max_inter = max(inters) J = sp.Symbol('J', real=True) Jij = [ N.matrix([[J, 0, 0], [0, J, 0], [0, 0, J]]) for i in range(max_inter + 1) ] if eigs == True: (Hsave, charpoly, eigs) = calculate_dispersion(lattice, num_uc, num, Jij, showEigs=eigs) print eigs eigs = eigs.keys() for eig in eigs: print eig.args eig = sp.simplify(eig.expand(deep=True, mul=True, multinomial=True)) return (Hsave, charpoly, eigs) else: Hsave = calculate_dispersion(lattice, num_uc, num, Jij, showEigs=eigs) return Hsave
def testChain(self, num = 3, num_uc = 1): ats = [rf.atom(pos = [i,0,0]) for i in range(num)] spin = rf.findmat(N.array([0,0,1])) ints = [[0],[0,1],[1]] nbrs = [[1],[0,2],[1]] for i in range(num): ats[i].interactions = ints[i] ats[i].neighbors = nbrs[i] ats[i].spinRmatrix = spin inters = [item for atom in ats for item in atom.interactions] max_inter = max(inters) J = sp.Symbol('J', real = True) Jij = [N.matrix([[J,0,0],[0,J,0],[0,0,J]]) for i in range(max_inter+1)] (Hsave, charpoly, eigs) = calculate_dispersion(ats, num_uc, num, Jij, showEigs = True) eigs = eigs.keys() for item in eigs: item = item.expand(mul = True, multinomial=True) testeig = (-8.0*self.J**2*self.S**2*sp.cos(self.kx) + 4.0*self.J**2*self.S**2 + 4.0*self.J**2*self.S**2*sp.cos(self.kx)**2)**(0.5) self.assertAlmostEqual(Hsave.shape[0],2,4, 'H wrong shape') self.assertAlmostEqual(Hsave.shape[1],2,4, 'H wrong shape') self.assert_(len(eigs[0].args)==len(testeig.args), 'Eig.arg lengths are different sizes') f = sp.simplify(eigs[0].args[0].expand()) f = f.subs([(self.J,1),(self.S,2),(self.kx,3),(self.ky,4),(self.kz,5)]) g = sp.simplify(testeig.args[0].expand()) g = g.subs([(self.J,1),(self.S,2),(self.kx,3),(self.ky,4),(self.kz,5)]) myFlag = f-g self.assertAlmostEqual(myFlag,0,7, 'Eigs are wrong')
def cfit_driver(jmats, atoms, spins, atomlist, N_atoms_uc, tau_list, hkl_interval, w_interval, direction, temperature): # Ground State opt_spins = opt_aux(atoms, jmats, spins) atom_list = add_spins(atoms, spins, atomlist) N_atoms = len(atom_list) # Dispersion Hsave = calculate_dispersion(atom_list, N_atoms_uc, N_atoms, jmats, showEigs=False) # Cross-section (atom_list, N_atoms_uc, csection, kaprange, tau_list, eig_list, kapvect, wt_list, fflist) = run_cross_section(None, None, tau_list, temperature, direction, hkl_interval, w_interval, atom_list=atom_list, N_atoms_uc=N_atoms_uc, Hsave=Hsave, nosave=True) x, y, z = run_eval_pointwise(N_atoms_uc, atom_list, csection, kaprange, tau_list, eig_list, kapvect, wt_list, fflist, temperature, direction) # Return 2d array return z
def testSquare(self, num=5, num_uc=1): ats = [rf.atom() for i in range(num)] spin = rf.findmat(N.array([0, 0, 1])) # Positions # 0 1 2 3 4 pstn = [[0, 0, 0], [0, 1, 0], [1, 0, 0], [0, -1, 0], [-1, 0, 0]] # Neighbors # 0 1 2 3 4 nbrs = [[1, 2, 3, 4], [0], [0], [0], [0]] # Interactions # 0 1 2 3 4 ints = [[0, 1, 2, 3], [0], [1], [2], [3]] for i in range(len(ats)): ats[i].pos = N.array(pstn[i]) ats[i].neighbors = nbrs[i] ats[i].interactions = ints[i] ats[i].spinRmatrix = spin ats[i].spinMagnitude = 1 inters = [item for atom in ats for item in atom.interactions] max_inter = max(inters) J = sp.Symbol('J', real=True) Jij = [ N.matrix([[J, 0, 0], [0, J, 0], [0, 0, J]]) for i in range(max_inter + 1) ] (Hsave, charpoly, eigs) = calculate_dispersion(ats, num_uc, num, Jij, showEigs=True) eigs = eigs.keys() for item in eigs: item = item.expand(mul=True, multinomial=True) testeig = ( -64.0 * self.J**2 * self.S**2 * sp.cos(self.kx) - 64.0 * self.J**2 * self.S**2 * sp.cos(self.ky) + 32.0 * self.J**2 * self.S**2 * sp.cos(self.kx) * sp.cos(self.ky) + 64.0 * self.J**2 * self.S**2 + 16.0 * self.J**2 * self.S**2 * sp.cos(self.kx)**2 + 16.0 * self.J**2 * self.S**2 * sp.cos(self.ky)**2)**(0.5) self.assertAlmostEqual(Hsave.shape[0], 2, 4, 'H wrong shape') self.assertAlmostEqual(Hsave.shape[1], 2, 4, 'H wrong shape') self.assert_( len(eigs[1].args) == len(testeig.args), 'Eig.arg lengths are different sizes') f = sp.simplify(eigs[1].args[0].expand()) f = f.subs([(self.J, 1), (self.S, 2), (self.kx, 3), (self.ky, 4), (self.kz, 5)]) g = sp.simplify(testeig.args[0].expand()) g = g.subs([(self.J, 1), (self.S, 2), (self.kx, 3), (self.ky, 4), (self.kz, 5)]) myFlag = f - g self.assertAlmostEqual(myFlag, 0, 7, 'Eigs are wrong')
def testFCC(self, num = 13, num_uc = 1): ats = [rf.atom() for i in range(num)] spin = rf.findmat(N.array([0,0,1])) aspin = rf.findmat(N.array([0,0,-1])) # Positions # 0 1 2 3 4 pstn = [[0,0,0], [0.5,0,0.5], [-0.5,0,0.5], [0.5,0,-0.5], [-0.5,0,-0.5], # 5 6 7 8 9 [0,0.5,0.5], [0,-0.5,0.5], [0,0.5,-0.5], [0,-0.5,-0.5], [0.5,0.5,0], # 10 11 12 [-0.5,0.5,0], [0.5,-0.5,0], [-0.5,-0.5,0]] # Neighbors # 0 1 2 3 4 nbrs = [[1,2,3,4,5,6,7,8,9,10,11,12], [], [], [], [], # 5 6 7 8 9 [], [], [], [], [], # 10 11 12 [], [], []] # Interactions # 0 1 2 3 4 ints = [[0,1,2,3,4,5,6,7,8,9,10,11], [], [], [], [], # 5 6 7 8 9 [], [], [], [], [], # 10 11 12 [], [], []] for i in range(len(ats)): ats[i].pos = N.array(pstn[i]) ats[i].neighbors = nbrs[i] ats[i].interactions = ints[i] ats[i].spinRmatrix = spin ats[i].spinMagnitude = 1 ats[0].spinMagnitude = 1 ats[0].spinRmatrix = aspin inters = [item for atom in ats for item in atom.interactions] max_inter = max(inters) J = sp.Symbol('J', real = True) Jij = [N.matrix([[J,0,0],[0,J,0],[0,0,J]]) for i in range(max_inter+1)] (Hsave, charpoly, eigs) = calculate_dispersion(ats, num_uc, num, Jij, showEigs = True) eigs = eigs.keys() for item in eigs: item = item.expand(mul = True, multinomial=True) testeig = (-128.0*self.J**2*self.S**2*sp.cos(0.5*self.kx)**2*sp.cos(0.5*self.ky)*sp.cos(0.5*self.kz) - 128.0*self.J**2*self.S**2*sp.cos(0.5*self.ky)**2*sp.cos(0.5*self.kx)*sp.cos(0.5*self.kz) - 128.0*self.J**2*self.S**2*sp.cos(0.5*self.kz)**2*sp.cos(0.5*self.kx)*sp.cos(0.5*self.ky) + 576.0*self.J**2*self.S**2 - 64.0*self.J**2*self.S**2*sp.cos(0.5*self.kx)**2*sp.cos(0.5*self.ky)**2 - 64.0*self.J**2*self.S**2*sp.cos(0.5*self.kx)**2*sp.cos(0.5*self.kz)**2 - 64.0*self.J**2*self.S**2*sp.cos(0.5*self.ky)**2*sp.cos(0.5*self.kz)**2)**(0.5) self.assertAlmostEqual(Hsave.shape[0],2,4, 'H wrong shape') self.assertAlmostEqual(Hsave.shape[1],2,4, 'H wrong shape') self.assert_(len(eigs[1].args)==len(testeig.args), 'Eig.arg lengths are different sizes') f = sp.simplify(eigs[1].args[0].expand()) f = f.subs([(self.J,1),(self.S,2),(self.kx,3),(self.ky,4),(self.kz,5)]) g = sp.simplify(testeig.args[0].expand()) g = g.subs([(self.J,1),(self.S,2),(self.kx,3),(self.ky,4),(self.kz,5)]) myFlag = f-g self.assertAlmostEqual(myFlag,0,7, 'Eigs are wrong')
def run_dispersion(lattice, num_uc = 1, eigs = False, eigsP = False): num = len(lattice) inters = [item for atom in lattice for item in atom.interactions] max_inter = max(inters) J = sp.Symbol('J', real = True) Jij = [N.matrix([[J,0,0],[0,J,0],[0,0,J]]) for i in range(max_inter+1)] if eigs == True: (Hsave, charpoly, eigs) = calculate_dispersion(lattice, num_uc, num, Jij, showEigs = eigs) print eigs eigs = eigs.keys() for eig in eigs: print eig.args eig = sp.simplify(eig.expand(deep = True, mul = True, multinomial=True)) return (Hsave, charpoly, eigs) else: Hsave = calculate_dispersion(lattice, num_uc, num, Jij , showEigs =eigs) return Hsave
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 testChain(self, num=3, num_uc=1): ats = [rf.atom(pos=[i, 0, 0]) for i in range(num)] spin = rf.findmat(N.array([0, 0, 1])) aspin = rf.findmat(N.array([0, 0, -1])) ints = [[0], [0, 1], [1]] nbrs = [[1], [0, 2], [1]] for i in range(num): ats[i].interactions = ints[i] ats[i].neighbors = nbrs[i] ats[i].spinRmatrix = spin ats[i].spinMagnitude = 1 for i in range(1, num, 2): ats[i].spinRmatrix = aspin ats[i].spinMagnitude = 1 inters = [item for atom in ats for item in atom.interactions] max_inter = max(inters) J = sp.Symbol('J', real=True) Jij = [ N.matrix([[J, 0, 0], [0, J, 0], [0, 0, J]]) for i in range(max_inter + 1) ] (Hsave, charpoly, eigs) = calculate_dispersion(ats, num_uc, num, Jij, showEigs=True) eigs = eigs.keys() for item in eigs: item = item.expand(mul=True, multinomial=True) testeig = (4 * self.J**2 * self.S**2 - 4.0 * self.J**2 * self.S**2 * sp.cos(self.kx)**2)**(0.5) self.assertAlmostEqual(Hsave.shape[0], 2, 4, 'H wrong shape') self.assertAlmostEqual(Hsave.shape[1], 2, 4, 'H wrong shape') self.assert_( len(eigs[0].args) == len(testeig.args), 'Eig.arg lengths are different sizes') f = sp.simplify(eigs[0].args[0].expand()) f = f.subs([(self.J, 1), (self.S, 2), (self.kx, 3), (self.ky, 4), (self.kz, 5)]) g = sp.simplify(testeig.args[0].expand()) g = g.subs([(self.J, 1), (self.S, 2), (self.kx, 3), (self.ky, 4), (self.kz, 5)]) myFlag = f - g self.assertAlmostEqual(myFlag, 0, 7, 'Eigs are wrong')
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 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 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): """ 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 testBCC(self, num=9, num_uc=1): ats = [rf.atom() for i in range(num)] spin = rf.findmat(N.array([0, 0, 1])) # Positions # 0 1 2 3 4 pstn = [ [0, 0, 0], [-0.5, 0.5, -0.5], [0.5, 0.5, -0.5], [0.5, 0.5, 0.5], [-0.5, 0.5, 0.5], # 5 6 7 8 [-0.5, -0.5, -0.5], [0.5, -0.5, -0.5], [0.5, -0.5, 0.5], [-0.5, -0.5, 0.5] ] # Neighbors # 0 1 2 3 4 nbrs = [ [1, 2, 3, 4, 5, 6, 7, 8], [], [], [], [], # 5 6 7 8 [], [], [], [] ] # Interactions # 0 1 2 3 4 ints = [ [0, 1, 2, 3, 4, 5, 6, 7], [], [], [], [], # 5 6 7 8 [], [], [], [] ] for i in range(len(ats)): ats[i].pos = N.array(pstn[i]) ats[i].neighbors = nbrs[i] ats[i].interactions = ints[i] ats[i].spinRmatrix = spin ats[i].spinMagnitude = 1 inters = [item for atom in ats for item in atom.interactions] max_inter = max(inters) J = sp.Symbol('J', real=True) Jij = [ N.matrix([[J, 0, 0], [0, J, 0], [0, 0, J]]) for i in range(max_inter + 1) ] (Hsave, charpoly, eigs) = calculate_dispersion(ats, num_uc, num, Jij, showEigs=True) eigs = eigs.keys() for item in eigs: item = item.expand(mul=True, multinomial=True) testeig = (-2048.0 * self.J**2 * self.S**2 * sp.cos(0.5 * self.kx) * sp.cos(0.5 * self.ky) * sp.cos(0.5 * self.kz) + 1024.0 * self.J**2 * self.S**2 + 1024.0 * self.J**2 * self.S**2 * sp.cos(0.5 * self.kx)**2 * sp.cos(0.5 * self.ky)**2 * sp.cos(0.5 * self.kz)**2)**( 0.5) * 0.5 self.assertAlmostEqual(Hsave.shape[0], 2, 4, 'H wrong shape') self.assertAlmostEqual(Hsave.shape[1], 2, 4, 'H wrong shape') f = eigs[0].args[2].args[1].args[0].expand() f = f.subs([(self.J, 1), (self.S, 2), (self.kx, 3), (self.ky, 4), (self.kz, 5), (sp.I, 0)]) g = sp.simplify(testeig.args[1].args[0].expand()) g = g.subs([(self.J, 1), (self.S, 2), (self.kx, 3), (self.ky, 4), (self.kz, 5)]) myFlag = f - g self.assertAlmostEqual(myFlag, 0, 7, 'Eigs are wrong')
def GetResult(self): print "fit list: ", self.fit_list #Propagate any value changes through all tied parameters for i in range(len(self.fit_list)): group = self._paramGroupList[i] print "group: ", group for param in group: #This will change the values in the matrices param.value = self.fit_list[i] monteCarloMats = [] #Used later for spinwave calculation jnums = [] jmats = [] print "matrices[0]: ", self._matrices[0].tolist() for i in range(len(self._matrices)): j11 = self._matrices[i][0][0].value j12 = self._matrices[i][0][1].value j13 = self._matrices[i][0][2].value j21 = self._matrices[i][1][0].value j22 = self._matrices[i][1][1].value j23 = self._matrices[i][1][2].value j31 = self._matrices[i][2][0].value j32 = self._matrices[i][2][1].value j33 = self._matrices[i][2][2].value monteCarloMats.append(numpy.array([[j11,j12,j13], [j21,j22,j23], [j31,j32,j33]])) #Used later for spinwave calculation jij=sympy.matrices.Matrix([[j11,j12,j13], [j21,j22,j23], [j31,j32,j33]]) jnums.append(i) jmats.append(jij) #Run the monteCarlo simulation #temporary (bad) method of picking tMin/tMax # jAvg = 0 # for mat in monteCarloMats: # jSum = 0 # for i in range(3): # for j in range(3): # val = abs(mat[i][j]) # jSum += val # jAvg += jSum/9 # # self._tMax = jAvg*12 # self._tMin = jAvg/10000 # self._tMax = 10 # self._tMin = 1E-6 print "\n\n\nmonte Carlo Mats:\n", monteCarloMats if self._runMCeveryTime or self._run == 0: #self._handle.write("\n\n\n\n\n------------Get Ground State---------------\n\n") self.spins = get_ground_state(self._k, self._tMax, self._tMin, self._tFactor, self._simpleAtoms, monteCarloMats) else: #self._handle.write("\n\n\n\n\n------------Opt Aux---------------\n\n") self.spins = opt_aux(self._simpleAtoms, monteCarloMats, self.spins) #self.spins = opt_aux(self._simpleAtoms, monteCarloMats, self.spins) #print "\nspins:\n", self.spins #self._handle.write("\n\n\n\nparam:\n\n") #self._handle.write(str(self.fit_list)) #self._handle.write("\n\nSpins After:\n\n") #self._handle.write(str(self.spins)) #self._handle.flush() def inUnitCell(atom): """Returns true of the atom is in the unit cell at Na, Nb, Nc, where those are the dimensions of the interaction cell. That cell is being used to ensure that it is completely surrounded and no interactions are left out. Handles simpleAtom type""" if atom.pos[0] >= self._interactionCellDimensions[0] and atom.pos[0] < (self._interactionCellDimensions[0] + 1): if atom.pos[1] >= self._interactionCellDimensions[1] and atom.pos[1] < (self._interactionCellDimensions[1] + 1): if atom.pos[2] >= self._interactionCellDimensions[2] and atom.pos[2] < (self._interactionCellDimensions[2] + 1): return True return False def inInteractionCell(atoms, atom): """Handles simpleAtom type.""" #First check if the atom is in the first crystallographic cell # if atom.pos[0] < 1.0 and atom.pos[1] < 1.0 and atom.pos[2] < 1.0: # return True #Now the crystallographic unit cell being used is at Na, Nb, Nc, not 0,0,0 if inUnitCell(atom): return True #If not, check if it bonds to an atom that is for i in range(len(atom.interactions)): if inUnitCell(atoms[atom.interactions[i][0]]): return True return False #Do the spinwave calculation spinwave_atoms = [] first_cell_atoms = 0 for i in range(len(self._simpleAtoms)): atom = self._simpleAtoms[i] if inInteractionCell(self._simpleAtoms, atom): Dx = atom.anisotropy[0] Dy = atom.anisotropy[1] Dz = atom.anisotropy[2] spinwave_atom = SpinwaveAtom(pos=atom.pos, Dx=Dx,Dy=Dy,Dz=Dz, orig_Index = i) rmat = findmat(self.spins[i])#indices match up spinwave_atom.spinRmatrix = rmat for interaction in atom.interactions: spinwave_atom.neighbors.append(interaction[0]) spinwave_atom.interactions.append(interaction[1]) spinwave_atoms.append(spinwave_atom) #x,y,z = spinwave_atom.pos #if x<1 and y<1 and z<1: # first_cell_atoms +=1 #Find atoms in desired cell and organize list so they come first tmp = [] for i in range(len(spinwave_atoms)): if inUnitCell(spinwave_atoms[i]): first_cell_atoms += 1 tmp.append(spinwave_atoms.pop(i)) for a in spinwave_atoms: tmp.append(a) spinwave_atoms = tmp #change interaction indices to match indices in new list for a in spinwave_atoms: neighborList = a.neighbors i = 0 while i < len(neighborList): neighbor_index = neighborList[i] for atom_index in range(len(spinwave_atoms)): atom = spinwave_atoms[atom_index] if atom.origIndex == neighbor_index: a.neighbors[i] = atom_index i +=1 break else:#This neighbor index is not in the interaction cell neighborList.pop(i) a.interactions.pop(i) N_atoms=len(spinwave_atoms) Hsave=calculate_dispersion(spinwave_atoms,first_cell_atoms,N_atoms,jmats ,showEigs=False) qrange = [] wrange = [] q = 0 for point in self.spinwave_domain: #print "point:", point wrange.append(calc_eigs(Hsave,point[0], point[1], point[2])) qrange.append(q) q += 1 wrange=numpy.real(wrange) wrange=numpy.array(wrange) wrange=numpy.real(wrange.T) #for wrange1 in wrange: # pylab.plot(qrange,wrange1,'s') #pylab.show() self._run+=1 #self._handle.write("\n\ndispersion:\n\n") #self._handle.write(str(wrange[0])) return wrange[0]#for now just one set
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)