def get_test_impurity_model(norb=2, ntau=1000, beta=10.0): """ Function that generates a random impurity model for testing """ from triqs.operators import c, c_dag, Operator, dagger from pyed.OperatorUtils import fundamental_operators_from_gf_struct from pyed.OperatorUtils import symmetrize_quartic_tensor from pyed.OperatorUtils import get_quadratic_operator from pyed.OperatorUtils import operator_from_quartic_tensor orb_idxs = list(np.arange(norb)) #print "orb_idxs ", orb_idxs spin_idxs = ['up', 'do'] gf_struct = [[spin_idx, orb_idxs] for spin_idx in spin_idxs] #print "gf_struct", gf_struct # -- Random Hamiltonian fundamental_operators = fundamental_operators_from_gf_struct(gf_struct) #print "fundamental_operators ", fundamental_operators N = len(fundamental_operators) t_OO = np.random.random((N, N)) + 1.j * np.random.random((N, N)) t_OO = 0.5 * (t_OO + np.conj(t_OO.T)) #print "N", N #print "t_OO", t_OO.shape #print 't_OO.real =\n', t_OO.real #print 't_OO.imag =\n', t_OO.imag U_OOOO = np.random.random((N, N, N, N)) + 1.j * np.random.random( (N, N, N, N)) U_OOOO = symmetrize_quartic_tensor(U_OOOO, conjugation=True) #print 'gf_struct =', gf_struct #print 'fundamental_operators = ', fundamental_operators H_loc = get_quadratic_operator(t_OO, fundamental_operators) + \ operator_from_quartic_tensor(U_OOOO, fundamental_operators) #print 'H_loc =', H_loc #print "H_loc.type", H_loc.type() from triqs.gf import MeshImTime, BlockGf mesh = MeshImTime(beta, 'Fermion', ntau) Delta_tau = BlockGf(mesh=mesh, gf_struct=gf_struct) #print "mesh", mesh #print "Delta_tau", Delta_tau for block_name, delta_tau in Delta_tau: delta_tau.data[:] = -0.5 return gf_struct, Delta_tau, H_loc
def test_quadratic(): n = 10 h_loc = np.random.random((n, n)) h_loc = 0.5 * (h_loc + h_loc.T) fund_op = [c(0, idx) for idx in range(n)] H_loc = get_quadratic_operator(h_loc, fund_op) h_loc_ref = quadratic_matrix_from_operator(H_loc, fund_op) np.testing.assert_array_almost_equal(h_loc, h_loc_ref)
def test_single_particle_transform(verbose=False): if verbose: print('--> test_single_particle_transform') h_loc = np.array([ [1.0, 0.0], [0.0, -1.0], ]) op_imp = [c(0, 0), c(0, 1)] H_loc = get_quadratic_operator(h_loc, op_imp) H_loc_ref = c_dag(0, 0) * c(0, 0) - c_dag(0, 1) * c(0, 1) assert ((H_loc - H_loc_ref).is_zero()) h_loc_ref = quadratic_matrix_from_operator(H_loc, op_imp) np.testing.assert_array_almost_equal(h_loc, h_loc_ref) if verbose: print('h_loc =\n', h_loc) print('h_loc_ref =\n', h_loc_ref) print('H_loc =', H_loc) T_ab = np.array([ [1., 1.], [1., -1.], ]) / np.sqrt(2.) Ht_loc = operator_single_particle_transform(H_loc, T_ab, op_imp) ht_loc = quadratic_matrix_from_operator(Ht_loc, op_imp) ht_loc_ref = np.array([ [0., 1.], [1., 0.], ]) Ht_loc_ref = c_dag(0, 0) * c(0, 1) + c_dag(0, 1) * c(0, 0) if verbose: print('ht_loc =\n', ht_loc) print('ht_loc_ref =\n', ht_loc_ref) print('Ht_loc =', Ht_loc) print('Ht_loc_ref =', Ht_loc_ref) assert ((Ht_loc - Ht_loc_ref).is_zero())
T_imp = block_diag(T_imp, T_imp) T_bath = block_diag(T_bath, T_bath) print 'V =\n', V print 'T_imp =\n', T_imp print 'T_bath =\n', T_bath T = np.block([[T_imp, V], [V.T, T_bath]]) print 'T =\n', T H_int = h_int_kanamori(spin_names, imp_idxs, np.array([[0, U - 3 * J], [U - 3 * J, 0]]), np.array([[U, U - 2 * J], [U - 2 * J, U]]), J, True) H = H_int + get_quadratic_operator(T, fop) up, do = spin_names index_converter = { (up, 0): ('loc', 0, 'up'), (do, 0): ('loc', 0, 'down'), (up, 1): ('loc', 1, 'up'), (do, 1): ('loc', 1, 'down'), (up, 2): ('loc', 2, 'up'), (do, 2): ('loc', 2, 'down'), (up, 3): ('loc', 3, 'up'), (do, 3): ('loc', 3, 'down'), (up, 4): ('loc', 4, 'up'), (do, 4): ('loc', 4, 'down'), (up, 5): ('loc', 5, 'up'), (do, 5): ('loc', 5, 'down'),
} # ------------------------------------------------------------------ # -- Setup Hamiltonian # -- Local crystal field h_loc = np.array([ [1.0, 0.0], [0.0, -1.0], ]) I = np.eye(p.num_spins) h_loc = np.kron(h_loc, I) p.H_loc = p.crystal_field * get_quadratic_operator(h_loc, p.op_imp) # -- Bath sites and hybridizations V2 = 1.0 V3 = 3.0 E2 = -1.0 E3 = -4.0 h_bath = np.array([ [0, 0, V2, 0], [0, 0, 0, V3], [V2, 0, E2, 0], [0, V3, 0, E3], ])